sqlglot.parser API documentation

Edit on GitHub

# sqlglot.parser

View Source

       1from __future__ import annotations
       2
       3import logging
       4import typing as t
       5from collections import defaultdict
       6
       7from sqlglot import exp
       8from sqlglot.errors import ErrorLevel, ParseError, concat_messages, merge_errors
       9from sqlglot.helper import apply_index_offset, ensure_list, seq_get
      10from sqlglot.time import format_time
      11from sqlglot.tokens import Token, Tokenizer, TokenType
      12from sqlglot.trie import TrieResult, in_trie, new_trie
      13
      14if t.TYPE_CHECKING:
      15    from sqlglot._typing import E, Lit
      16    from sqlglot.dialects.dialect import Dialect, DialectType
      17
      18logger = logging.getLogger("sqlglot")
      19
      20
      21def parse_var_map(args: t.List) -> exp.StarMap | exp.VarMap:
      22    if len(args) == 1 and args[0].is_star:
      23        return exp.StarMap(this=args[0])
      24
      25    keys = []
      26    values = []
      27    for i in range(0, len(args), 2):
      28        keys.append(args[i])
      29        values.append(args[i + 1])
      30
      31    return exp.VarMap(
      32        keys=exp.Array(expressions=keys),
      33        values=exp.Array(expressions=values),
      34    )
      35
      36
      37def parse_like(args: t.List) -> exp.Escape | exp.Like:
      38    like = exp.Like(this=seq_get(args, 1), expression=seq_get(args, 0))
      39    return exp.Escape(this=like, expression=seq_get(args, 2)) if len(args) > 2 else like
      40
      41
      42def binary_range_parser(
      43    expr_type: t.Type[exp.Expression],
      44) -> t.Callable[[Parser, t.Optional[exp.Expression]], t.Optional[exp.Expression]]:
      45    return lambda self, this: self._parse_escape(
      46        self.expression(expr_type, this=this, expression=self._parse_bitwise())
      47    )
      48
      49
      50def parse_logarithm(args: t.List, dialect: Dialect) -> exp.Func:
      51    # Default argument order is base, expression
      52    this = seq_get(args, 0)
      53    expression = seq_get(args, 1)
      54
      55    if expression:
      56        if not dialect.LOG_BASE_FIRST:
      57            this, expression = expression, this
      58        return exp.Log(this=this, expression=expression)
      59
      60    return (exp.Ln if dialect.parser_class.LOG_DEFAULTS_TO_LN else exp.Log)(this=this)
      61
      62
      63def parse_extract_json_with_path(expr_type: t.Type[E]) -> t.Callable[[t.List, Dialect], E]:
      64    def _parser(args: t.List, dialect: Dialect) -> E:
      65        expression = expr_type(
      66            this=seq_get(args, 0), expression=dialect.to_json_path(seq_get(args, 1))
      67        )
      68        if len(args) > 2 and expr_type is exp.JSONExtract:
      69            expression.set("expressions", args[2:])
      70
      71        return expression
      72
      73    return _parser
      74
      75
      76class _Parser(type):
      77    def __new__(cls, clsname, bases, attrs):
      78        klass = super().__new__(cls, clsname, bases, attrs)
      79
      80        klass.SHOW_TRIE = new_trie(key.split(" ") for key in klass.SHOW_PARSERS)
      81        klass.SET_TRIE = new_trie(key.split(" ") for key in klass.SET_PARSERS)
      82
      83        return klass
      84
      85
      86class Parser(metaclass=_Parser):
      87    """
      88    Parser consumes a list of tokens produced by the Tokenizer and produces a parsed syntax tree.
      89
      90    Args:
      91        error_level: The desired error level.
      92            Default: ErrorLevel.IMMEDIATE
      93        error_message_context: Determines the amount of context to capture from a
      94            query string when displaying the error message (in number of characters).
      95            Default: 100
      96        max_errors: Maximum number of error messages to include in a raised ParseError.
      97            This is only relevant if error_level is ErrorLevel.RAISE.
      98            Default: 3
      99    """
     100
     101    FUNCTIONS: t.Dict[str, t.Callable] = {
     102        **{name: func.from_arg_list for name, func in exp.FUNCTION_BY_NAME.items()},
     103        "CONCAT": lambda args, dialect: exp.Concat(
     104            expressions=args,
     105            safe=not dialect.STRICT_STRING_CONCAT,
     106            coalesce=dialect.CONCAT_COALESCE,
     107        ),
     108        "CONCAT_WS": lambda args, dialect: exp.ConcatWs(
     109            expressions=args,
     110            safe=not dialect.STRICT_STRING_CONCAT,
     111            coalesce=dialect.CONCAT_COALESCE,
     112        ),
     113        "DATE_TO_DATE_STR": lambda args: exp.Cast(
     114            this=seq_get(args, 0),
     115            to=exp.DataType(this=exp.DataType.Type.TEXT),
     116        ),
     117        "GLOB": lambda args: exp.Glob(this=seq_get(args, 1), expression=seq_get(args, 0)),
     118        "JSON_EXTRACT": parse_extract_json_with_path(exp.JSONExtract),
     119        "JSON_EXTRACT_SCALAR": parse_extract_json_with_path(exp.JSONExtractScalar),
     120        "JSON_EXTRACT_PATH_TEXT": parse_extract_json_with_path(exp.JSONExtractScalar),
     121        "LIKE": parse_like,
     122        "LOG": parse_logarithm,
     123        "TIME_TO_TIME_STR": lambda args: exp.Cast(
     124            this=seq_get(args, 0),
     125            to=exp.DataType(this=exp.DataType.Type.TEXT),
     126        ),
     127        "TS_OR_DS_TO_DATE_STR": lambda args: exp.Substring(
     128            this=exp.Cast(
     129                this=seq_get(args, 0),
     130                to=exp.DataType(this=exp.DataType.Type.TEXT),
     131            ),
     132            start=exp.Literal.number(1),
     133            length=exp.Literal.number(10),
     134        ),
     135        "VAR_MAP": parse_var_map,
     136    }
     137
     138    NO_PAREN_FUNCTIONS = {
     139        TokenType.CURRENT_DATE: exp.CurrentDate,
     140        TokenType.CURRENT_DATETIME: exp.CurrentDate,
     141        TokenType.CURRENT_TIME: exp.CurrentTime,
     142        TokenType.CURRENT_TIMESTAMP: exp.CurrentTimestamp,
     143        TokenType.CURRENT_USER: exp.CurrentUser,
     144    }
     145
     146    STRUCT_TYPE_TOKENS = {
     147        TokenType.NESTED,
     148        TokenType.STRUCT,
     149    }
     150
     151    NESTED_TYPE_TOKENS = {
     152        TokenType.ARRAY,
     153        TokenType.LOWCARDINALITY,
     154        TokenType.MAP,
     155        TokenType.NULLABLE,
     156        *STRUCT_TYPE_TOKENS,
     157    }
     158
     159    ENUM_TYPE_TOKENS = {
     160        TokenType.ENUM,
     161        TokenType.ENUM8,
     162        TokenType.ENUM16,
     163    }
     164
     165    AGGREGATE_TYPE_TOKENS = {
     166        TokenType.AGGREGATEFUNCTION,
     167        TokenType.SIMPLEAGGREGATEFUNCTION,
     168    }
     169
     170    TYPE_TOKENS = {
     171        TokenType.BIT,
     172        TokenType.BOOLEAN,
     173        TokenType.TINYINT,
     174        TokenType.UTINYINT,
     175        TokenType.SMALLINT,
     176        TokenType.USMALLINT,
     177        TokenType.INT,
     178        TokenType.UINT,
     179        TokenType.BIGINT,
     180        TokenType.UBIGINT,
     181        TokenType.INT128,
     182        TokenType.UINT128,
     183        TokenType.INT256,
     184        TokenType.UINT256,
     185        TokenType.MEDIUMINT,
     186        TokenType.UMEDIUMINT,
     187        TokenType.FIXEDSTRING,
     188        TokenType.FLOAT,
     189        TokenType.DOUBLE,
     190        TokenType.CHAR,
     191        TokenType.NCHAR,
     192        TokenType.VARCHAR,
     193        TokenType.NVARCHAR,
     194        TokenType.BPCHAR,
     195        TokenType.TEXT,
     196        TokenType.MEDIUMTEXT,
     197        TokenType.LONGTEXT,
     198        TokenType.MEDIUMBLOB,
     199        TokenType.LONGBLOB,
     200        TokenType.BINARY,
     201        TokenType.VARBINARY,
     202        TokenType.JSON,
     203        TokenType.JSONB,
     204        TokenType.INTERVAL,
     205        TokenType.TINYBLOB,
     206        TokenType.TINYTEXT,
     207        TokenType.TIME,
     208        TokenType.TIMETZ,
     209        TokenType.TIMESTAMP,
     210        TokenType.TIMESTAMP_S,
     211        TokenType.TIMESTAMP_MS,
     212        TokenType.TIMESTAMP_NS,
     213        TokenType.TIMESTAMPTZ,
     214        TokenType.TIMESTAMPLTZ,
     215        TokenType.DATETIME,
     216        TokenType.DATETIME64,
     217        TokenType.DATE,
     218        TokenType.DATE32,
     219        TokenType.INT4RANGE,
     220        TokenType.INT4MULTIRANGE,
     221        TokenType.INT8RANGE,
     222        TokenType.INT8MULTIRANGE,
     223        TokenType.NUMRANGE,
     224        TokenType.NUMMULTIRANGE,
     225        TokenType.TSRANGE,
     226        TokenType.TSMULTIRANGE,
     227        TokenType.TSTZRANGE,
     228        TokenType.TSTZMULTIRANGE,
     229        TokenType.DATERANGE,
     230        TokenType.DATEMULTIRANGE,
     231        TokenType.DECIMAL,
     232        TokenType.UDECIMAL,
     233        TokenType.BIGDECIMAL,
     234        TokenType.UUID,
     235        TokenType.GEOGRAPHY,
     236        TokenType.GEOMETRY,
     237        TokenType.HLLSKETCH,
     238        TokenType.HSTORE,
     239        TokenType.PSEUDO_TYPE,
     240        TokenType.SUPER,
     241        TokenType.SERIAL,
     242        TokenType.SMALLSERIAL,
     243        TokenType.BIGSERIAL,
     244        TokenType.XML,
     245        TokenType.YEAR,
     246        TokenType.UNIQUEIDENTIFIER,
     247        TokenType.USERDEFINED,
     248        TokenType.MONEY,
     249        TokenType.SMALLMONEY,
     250        TokenType.ROWVERSION,
     251        TokenType.IMAGE,
     252        TokenType.VARIANT,
     253        TokenType.OBJECT,
     254        TokenType.OBJECT_IDENTIFIER,
     255        TokenType.INET,
     256        TokenType.IPADDRESS,
     257        TokenType.IPPREFIX,
     258        TokenType.IPV4,
     259        TokenType.IPV6,
     260        TokenType.UNKNOWN,
     261        TokenType.NULL,
     262        *ENUM_TYPE_TOKENS,
     263        *NESTED_TYPE_TOKENS,
     264        *AGGREGATE_TYPE_TOKENS,
     265    }
     266
     267    SIGNED_TO_UNSIGNED_TYPE_TOKEN = {
     268        TokenType.BIGINT: TokenType.UBIGINT,
     269        TokenType.INT: TokenType.UINT,
     270        TokenType.MEDIUMINT: TokenType.UMEDIUMINT,
     271        TokenType.SMALLINT: TokenType.USMALLINT,
     272        TokenType.TINYINT: TokenType.UTINYINT,
     273        TokenType.DECIMAL: TokenType.UDECIMAL,
     274    }
     275
     276    SUBQUERY_PREDICATES = {
     277        TokenType.ANY: exp.Any,
     278        TokenType.ALL: exp.All,
     279        TokenType.EXISTS: exp.Exists,
     280        TokenType.SOME: exp.Any,
     281    }
     282
     283    RESERVED_TOKENS = {
     284        *Tokenizer.SINGLE_TOKENS.values(),
     285        TokenType.SELECT,
     286    }
     287
     288    DB_CREATABLES = {
     289        TokenType.DATABASE,
     290        TokenType.SCHEMA,
     291        TokenType.TABLE,
     292        TokenType.VIEW,
     293        TokenType.MODEL,
     294        TokenType.DICTIONARY,
     295    }
     296
     297    CREATABLES = {
     298        TokenType.COLUMN,
     299        TokenType.CONSTRAINT,
     300        TokenType.FUNCTION,
     301        TokenType.INDEX,
     302        TokenType.PROCEDURE,
     303        TokenType.FOREIGN_KEY,
     304        *DB_CREATABLES,
     305    }
     306
     307    # Tokens that can represent identifiers
     308    ID_VAR_TOKENS = {
     309        TokenType.VAR,
     310        TokenType.ANTI,
     311        TokenType.APPLY,
     312        TokenType.ASC,
     313        TokenType.AUTO_INCREMENT,
     314        TokenType.BEGIN,
     315        TokenType.BPCHAR,
     316        TokenType.CACHE,
     317        TokenType.CASE,
     318        TokenType.COLLATE,
     319        TokenType.COMMAND,
     320        TokenType.COMMENT,
     321        TokenType.COMMIT,
     322        TokenType.CONSTRAINT,
     323        TokenType.DEFAULT,
     324        TokenType.DELETE,
     325        TokenType.DESC,
     326        TokenType.DESCRIBE,
     327        TokenType.DICTIONARY,
     328        TokenType.DIV,
     329        TokenType.END,
     330        TokenType.EXECUTE,
     331        TokenType.ESCAPE,
     332        TokenType.FALSE,
     333        TokenType.FIRST,
     334        TokenType.FILTER,
     335        TokenType.FINAL,
     336        TokenType.FORMAT,
     337        TokenType.FULL,
     338        TokenType.IS,
     339        TokenType.ISNULL,
     340        TokenType.INTERVAL,
     341        TokenType.KEEP,
     342        TokenType.KILL,
     343        TokenType.LEFT,
     344        TokenType.LOAD,
     345        TokenType.MERGE,
     346        TokenType.NATURAL,
     347        TokenType.NEXT,
     348        TokenType.OFFSET,
     349        TokenType.OPERATOR,
     350        TokenType.ORDINALITY,
     351        TokenType.OVERLAPS,
     352        TokenType.OVERWRITE,
     353        TokenType.PARTITION,
     354        TokenType.PERCENT,
     355        TokenType.PIVOT,
     356        TokenType.PRAGMA,
     357        TokenType.RANGE,
     358        TokenType.RECURSIVE,
     359        TokenType.REFERENCES,
     360        TokenType.REFRESH,
     361        TokenType.REPLACE,
     362        TokenType.RIGHT,
     363        TokenType.ROW,
     364        TokenType.ROWS,
     365        TokenType.SEMI,
     366        TokenType.SET,
     367        TokenType.SETTINGS,
     368        TokenType.SHOW,
     369        TokenType.TEMPORARY,
     370        TokenType.TOP,
     371        TokenType.TRUE,
     372        TokenType.UNIQUE,
     373        TokenType.UNPIVOT,
     374        TokenType.UPDATE,
     375        TokenType.USE,
     376        TokenType.VOLATILE,
     377        TokenType.WINDOW,
     378        *CREATABLES,
     379        *SUBQUERY_PREDICATES,
     380        *TYPE_TOKENS,
     381        *NO_PAREN_FUNCTIONS,
     382    }
     383
     384    INTERVAL_VARS = ID_VAR_TOKENS - {TokenType.END}
     385
     386    TABLE_ALIAS_TOKENS = ID_VAR_TOKENS - {
     387        TokenType.ANTI,
     388        TokenType.APPLY,
     389        TokenType.ASOF,
     390        TokenType.FULL,
     391        TokenType.LEFT,
     392        TokenType.LOCK,
     393        TokenType.NATURAL,
     394        TokenType.OFFSET,
     395        TokenType.RIGHT,
     396        TokenType.SEMI,
     397        TokenType.WINDOW,
     398    }
     399
     400    COMMENT_TABLE_ALIAS_TOKENS = TABLE_ALIAS_TOKENS - {TokenType.IS}
     401
     402    UPDATE_ALIAS_TOKENS = TABLE_ALIAS_TOKENS - {TokenType.SET}
     403
     404    TRIM_TYPES = {"LEADING", "TRAILING", "BOTH"}
     405
     406    FUNC_TOKENS = {
     407        TokenType.COLLATE,
     408        TokenType.COMMAND,
     409        TokenType.CURRENT_DATE,
     410        TokenType.CURRENT_DATETIME,
     411        TokenType.CURRENT_TIMESTAMP,
     412        TokenType.CURRENT_TIME,
     413        TokenType.CURRENT_USER,
     414        TokenType.FILTER,
     415        TokenType.FIRST,
     416        TokenType.FORMAT,
     417        TokenType.GLOB,
     418        TokenType.IDENTIFIER,
     419        TokenType.INDEX,
     420        TokenType.ISNULL,
     421        TokenType.ILIKE,
     422        TokenType.INSERT,
     423        TokenType.LIKE,
     424        TokenType.MERGE,
     425        TokenType.OFFSET,
     426        TokenType.PRIMARY_KEY,
     427        TokenType.RANGE,
     428        TokenType.REPLACE,
     429        TokenType.RLIKE,
     430        TokenType.ROW,
     431        TokenType.UNNEST,
     432        TokenType.VAR,
     433        TokenType.LEFT,
     434        TokenType.RIGHT,
     435        TokenType.DATE,
     436        TokenType.DATETIME,
     437        TokenType.TABLE,
     438        TokenType.TIMESTAMP,
     439        TokenType.TIMESTAMPTZ,
     440        TokenType.WINDOW,
     441        TokenType.XOR,
     442        *TYPE_TOKENS,
     443        *SUBQUERY_PREDICATES,
     444    }
     445
     446    CONJUNCTION = {
     447        TokenType.AND: exp.And,
     448        TokenType.OR: exp.Or,
     449    }
     450
     451    EQUALITY = {
     452        TokenType.COLON_EQ: exp.PropertyEQ,
     453        TokenType.EQ: exp.EQ,
     454        TokenType.NEQ: exp.NEQ,
     455        TokenType.NULLSAFE_EQ: exp.NullSafeEQ,
     456    }
     457
     458    COMPARISON = {
     459        TokenType.GT: exp.GT,
     460        TokenType.GTE: exp.GTE,
     461        TokenType.LT: exp.LT,
     462        TokenType.LTE: exp.LTE,
     463    }
     464
     465    BITWISE = {
     466        TokenType.AMP: exp.BitwiseAnd,
     467        TokenType.CARET: exp.BitwiseXor,
     468        TokenType.PIPE: exp.BitwiseOr,
     469    }
     470
     471    TERM = {
     472        TokenType.DASH: exp.Sub,
     473        TokenType.PLUS: exp.Add,
     474        TokenType.MOD: exp.Mod,
     475        TokenType.COLLATE: exp.Collate,
     476    }
     477
     478    FACTOR = {
     479        TokenType.DIV: exp.IntDiv,
     480        TokenType.LR_ARROW: exp.Distance,
     481        TokenType.SLASH: exp.Div,
     482        TokenType.STAR: exp.Mul,
     483    }
     484
     485    EXPONENT: t.Dict[TokenType, t.Type[exp.Expression]] = {}
     486
     487    TIMES = {
     488        TokenType.TIME,
     489        TokenType.TIMETZ,
     490    }
     491
     492    TIMESTAMPS = {
     493        TokenType.TIMESTAMP,
     494        TokenType.TIMESTAMPTZ,
     495        TokenType.TIMESTAMPLTZ,
     496        *TIMES,
     497    }
     498
     499    SET_OPERATIONS = {
     500        TokenType.UNION,
     501        TokenType.INTERSECT,
     502        TokenType.EXCEPT,
     503    }
     504
     505    JOIN_METHODS = {
     506        TokenType.NATURAL,
     507        TokenType.ASOF,
     508    }
     509
     510    JOIN_SIDES = {
     511        TokenType.LEFT,
     512        TokenType.RIGHT,
     513        TokenType.FULL,
     514    }
     515
     516    JOIN_KINDS = {
     517        TokenType.INNER,
     518        TokenType.OUTER,
     519        TokenType.CROSS,
     520        TokenType.SEMI,
     521        TokenType.ANTI,
     522    }
     523
     524    JOIN_HINTS: t.Set[str] = set()
     525
     526    LAMBDAS = {
     527        TokenType.ARROW: lambda self, expressions: self.expression(
     528            exp.Lambda,
     529            this=self._replace_lambda(
     530                self._parse_conjunction(),
     531                {node.name for node in expressions},
     532            ),
     533            expressions=expressions,
     534        ),
     535        TokenType.FARROW: lambda self, expressions: self.expression(
     536            exp.Kwarg,
     537            this=exp.var(expressions[0].name),
     538            expression=self._parse_conjunction(),
     539        ),
     540    }
     541
     542    COLUMN_OPERATORS = {
     543        TokenType.DOT: None,
     544        TokenType.DCOLON: lambda self, this, to: self.expression(
     545            exp.Cast if self.STRICT_CAST else exp.TryCast,
     546            this=this,
     547            to=to,
     548        ),
     549        TokenType.ARROW: lambda self, this, path: self.expression(
     550            exp.JSONExtract,
     551            this=this,
     552            expression=self.dialect.to_json_path(path),
     553        ),
     554        TokenType.DARROW: lambda self, this, path: self.expression(
     555            exp.JSONExtractScalar,
     556            this=this,
     557            expression=self.dialect.to_json_path(path),
     558        ),
     559        TokenType.HASH_ARROW: lambda self, this, path: self.expression(
     560            exp.JSONBExtract,
     561            this=this,
     562            expression=path,
     563        ),
     564        TokenType.DHASH_ARROW: lambda self, this, path: self.expression(
     565            exp.JSONBExtractScalar,
     566            this=this,
     567            expression=path,
     568        ),
     569        TokenType.PLACEHOLDER: lambda self, this, key: self.expression(
     570            exp.JSONBContains,
     571            this=this,
     572            expression=key,
     573        ),
     574    }
     575
     576    EXPRESSION_PARSERS = {
     577        exp.Cluster: lambda self: self._parse_sort(exp.Cluster, TokenType.CLUSTER_BY),
     578        exp.Column: lambda self: self._parse_column(),
     579        exp.Condition: lambda self: self._parse_conjunction(),
     580        exp.DataType: lambda self: self._parse_types(allow_identifiers=False),
     581        exp.Expression: lambda self: self._parse_statement(),
     582        exp.From: lambda self: self._parse_from(),
     583        exp.Group: lambda self: self._parse_group(),
     584        exp.Having: lambda self: self._parse_having(),
     585        exp.Identifier: lambda self: self._parse_id_var(),
     586        exp.Join: lambda self: self._parse_join(),
     587        exp.Lambda: lambda self: self._parse_lambda(),
     588        exp.Lateral: lambda self: self._parse_lateral(),
     589        exp.Limit: lambda self: self._parse_limit(),
     590        exp.Offset: lambda self: self._parse_offset(),
     591        exp.Order: lambda self: self._parse_order(),
     592        exp.Ordered: lambda self: self._parse_ordered(),
     593        exp.Properties: lambda self: self._parse_properties(),
     594        exp.Qualify: lambda self: self._parse_qualify(),
     595        exp.Returning: lambda self: self._parse_returning(),
     596        exp.Sort: lambda self: self._parse_sort(exp.Sort, TokenType.SORT_BY),
     597        exp.Table: lambda self: self._parse_table_parts(),
     598        exp.TableAlias: lambda self: self._parse_table_alias(),
     599        exp.When: lambda self: seq_get(self._parse_when_matched(), 0),
     600        exp.Where: lambda self: self._parse_where(),
     601        exp.Window: lambda self: self._parse_named_window(),
     602        exp.With: lambda self: self._parse_with(),
     603        "JOIN_TYPE": lambda self: self._parse_join_parts(),
     604    }
     605
     606    STATEMENT_PARSERS = {
     607        TokenType.ALTER: lambda self: self._parse_alter(),
     608        TokenType.BEGIN: lambda self: self._parse_transaction(),
     609        TokenType.CACHE: lambda self: self._parse_cache(),
     610        TokenType.COMMIT: lambda self: self._parse_commit_or_rollback(),
     611        TokenType.COMMENT: lambda self: self._parse_comment(),
     612        TokenType.CREATE: lambda self: self._parse_create(),
     613        TokenType.DELETE: lambda self: self._parse_delete(),
     614        TokenType.DESC: lambda self: self._parse_describe(),
     615        TokenType.DESCRIBE: lambda self: self._parse_describe(),
     616        TokenType.DROP: lambda self: self._parse_drop(),
     617        TokenType.INSERT: lambda self: self._parse_insert(),
     618        TokenType.KILL: lambda self: self._parse_kill(),
     619        TokenType.LOAD: lambda self: self._parse_load(),
     620        TokenType.MERGE: lambda self: self._parse_merge(),
     621        TokenType.PIVOT: lambda self: self._parse_simplified_pivot(),
     622        TokenType.PRAGMA: lambda self: self.expression(exp.Pragma, this=self._parse_expression()),
     623        TokenType.REFRESH: lambda self: self._parse_refresh(),
     624        TokenType.ROLLBACK: lambda self: self._parse_commit_or_rollback(),
     625        TokenType.SET: lambda self: self._parse_set(),
     626        TokenType.UNCACHE: lambda self: self._parse_uncache(),
     627        TokenType.UPDATE: lambda self: self._parse_update(),
     628        TokenType.USE: lambda self: self.expression(
     629            exp.Use,
     630            kind=self._match_texts(("ROLE", "WAREHOUSE", "DATABASE", "SCHEMA"))
     631            and exp.var(self._prev.text),
     632            this=self._parse_table(schema=False),
     633        ),
     634    }
     635
     636    UNARY_PARSERS = {
     637        TokenType.PLUS: lambda self: self._parse_unary(),  # Unary + is handled as a no-op
     638        TokenType.NOT: lambda self: self.expression(exp.Not, this=self._parse_equality()),
     639        TokenType.TILDA: lambda self: self.expression(exp.BitwiseNot, this=self._parse_unary()),
     640        TokenType.DASH: lambda self: self.expression(exp.Neg, this=self._parse_unary()),
     641    }
     642
     643    PRIMARY_PARSERS = {
     644        TokenType.STRING: lambda self, token: self.expression(
     645            exp.Literal, this=token.text, is_string=True
     646        ),
     647        TokenType.NUMBER: lambda self, token: self.expression(
     648            exp.Literal, this=token.text, is_string=False
     649        ),
     650        TokenType.STAR: lambda self, _: self.expression(
     651            exp.Star, **{"except": self._parse_except(), "replace": self._parse_replace()}
     652        ),
     653        TokenType.NULL: lambda self, _: self.expression(exp.Null),
     654        TokenType.TRUE: lambda self, _: self.expression(exp.Boolean, this=True),
     655        TokenType.FALSE: lambda self, _: self.expression(exp.Boolean, this=False),
     656        TokenType.BIT_STRING: lambda self, token: self.expression(exp.BitString, this=token.text),
     657        TokenType.HEX_STRING: lambda self, token: self.expression(exp.HexString, this=token.text),
     658        TokenType.BYTE_STRING: lambda self, token: self.expression(exp.ByteString, this=token.text),
     659        TokenType.INTRODUCER: lambda self, token: self._parse_introducer(token),
     660        TokenType.NATIONAL_STRING: lambda self, token: self.expression(
     661            exp.National, this=token.text
     662        ),
     663        TokenType.RAW_STRING: lambda self, token: self.expression(exp.RawString, this=token.text),
     664        TokenType.HEREDOC_STRING: lambda self, token: self.expression(
     665            exp.RawString, this=token.text
     666        ),
     667        TokenType.UNICODE_STRING: lambda self, token: self.expression(
     668            exp.UnicodeString,
     669            this=token.text,
     670            escape=self._match_text_seq("UESCAPE") and self._parse_string(),
     671        ),
     672        TokenType.SESSION_PARAMETER: lambda self, _: self._parse_session_parameter(),
     673    }
     674
     675    PLACEHOLDER_PARSERS = {
     676        TokenType.PLACEHOLDER: lambda self: self.expression(exp.Placeholder),
     677        TokenType.PARAMETER: lambda self: self._parse_parameter(),
     678        TokenType.COLON: lambda self: (
     679            self.expression(exp.Placeholder, this=self._prev.text)
     680            if self._match(TokenType.NUMBER) or self._match_set(self.ID_VAR_TOKENS)
     681            else None
     682        ),
     683    }
     684
     685    RANGE_PARSERS = {
     686        TokenType.BETWEEN: lambda self, this: self._parse_between(this),
     687        TokenType.GLOB: binary_range_parser(exp.Glob),
     688        TokenType.ILIKE: binary_range_parser(exp.ILike),
     689        TokenType.IN: lambda self, this: self._parse_in(this),
     690        TokenType.IRLIKE: binary_range_parser(exp.RegexpILike),
     691        TokenType.IS: lambda self, this: self._parse_is(this),
     692        TokenType.LIKE: binary_range_parser(exp.Like),
     693        TokenType.OVERLAPS: binary_range_parser(exp.Overlaps),
     694        TokenType.RLIKE: binary_range_parser(exp.RegexpLike),
     695        TokenType.SIMILAR_TO: binary_range_parser(exp.SimilarTo),
     696        TokenType.FOR: lambda self, this: self._parse_comprehension(this),
     697    }
     698
     699    PROPERTY_PARSERS: t.Dict[str, t.Callable] = {
     700        "ALGORITHM": lambda self: self._parse_property_assignment(exp.AlgorithmProperty),
     701        "AUTO": lambda self: self._parse_auto_property(),
     702        "AUTO_INCREMENT": lambda self: self._parse_property_assignment(exp.AutoIncrementProperty),
     703        "BLOCKCOMPRESSION": lambda self: self._parse_blockcompression(),
     704        "CHARSET": lambda self, **kwargs: self._parse_character_set(**kwargs),
     705        "CHARACTER SET": lambda self, **kwargs: self._parse_character_set(**kwargs),
     706        "CHECKSUM": lambda self: self._parse_checksum(),
     707        "CLUSTER BY": lambda self: self._parse_cluster(),
     708        "CLUSTERED": lambda self: self._parse_clustered_by(),
     709        "COLLATE": lambda self, **kwargs: self._parse_property_assignment(
     710            exp.CollateProperty, **kwargs
     711        ),
     712        "COMMENT": lambda self: self._parse_property_assignment(exp.SchemaCommentProperty),
     713        "CONTAINS": lambda self: self._parse_contains_property(),
     714        "COPY": lambda self: self._parse_copy_property(),
     715        "DATABLOCKSIZE": lambda self, **kwargs: self._parse_datablocksize(**kwargs),
     716        "DEFINER": lambda self: self._parse_definer(),
     717        "DETERMINISTIC": lambda self: self.expression(
     718            exp.StabilityProperty, this=exp.Literal.string("IMMUTABLE")
     719        ),
     720        "DISTKEY": lambda self: self._parse_distkey(),
     721        "DISTSTYLE": lambda self: self._parse_property_assignment(exp.DistStyleProperty),
     722        "ENGINE": lambda self: self._parse_property_assignment(exp.EngineProperty),
     723        "EXECUTE": lambda self: self._parse_property_assignment(exp.ExecuteAsProperty),
     724        "EXTERNAL": lambda self: self.expression(exp.ExternalProperty),
     725        "FALLBACK": lambda self, **kwargs: self._parse_fallback(**kwargs),
     726        "FORMAT": lambda self: self._parse_property_assignment(exp.FileFormatProperty),
     727        "FREESPACE": lambda self: self._parse_freespace(),
     728        "HEAP": lambda self: self.expression(exp.HeapProperty),
     729        "IMMUTABLE": lambda self: self.expression(
     730            exp.StabilityProperty, this=exp.Literal.string("IMMUTABLE")
     731        ),
     732        "INHERITS": lambda self: self.expression(
     733            exp.InheritsProperty, expressions=self._parse_wrapped_csv(self._parse_table)
     734        ),
     735        "INPUT": lambda self: self.expression(exp.InputModelProperty, this=self._parse_schema()),
     736        "JOURNAL": lambda self, **kwargs: self._parse_journal(**kwargs),
     737        "LANGUAGE": lambda self: self._parse_property_assignment(exp.LanguageProperty),
     738        "LAYOUT": lambda self: self._parse_dict_property(this="LAYOUT"),
     739        "LIFETIME": lambda self: self._parse_dict_range(this="LIFETIME"),
     740        "LIKE": lambda self: self._parse_create_like(),
     741        "LOCATION": lambda self: self._parse_property_assignment(exp.LocationProperty),
     742        "LOCK": lambda self: self._parse_locking(),
     743        "LOCKING": lambda self: self._parse_locking(),
     744        "LOG": lambda self, **kwargs: self._parse_log(**kwargs),
     745        "MATERIALIZED": lambda self: self.expression(exp.MaterializedProperty),
     746        "MERGEBLOCKRATIO": lambda self, **kwargs: self._parse_mergeblockratio(**kwargs),
     747        "MODIFIES": lambda self: self._parse_modifies_property(),
     748        "MULTISET": lambda self: self.expression(exp.SetProperty, multi=True),
     749        "NO": lambda self: self._parse_no_property(),
     750        "ON": lambda self: self._parse_on_property(),
     751        "ORDER BY": lambda self: self._parse_order(skip_order_token=True),
     752        "OUTPUT": lambda self: self.expression(exp.OutputModelProperty, this=self._parse_schema()),
     753        "PARTITION": lambda self: self._parse_partitioned_of(),
     754        "PARTITION BY": lambda self: self._parse_partitioned_by(),
     755        "PARTITIONED BY": lambda self: self._parse_partitioned_by(),
     756        "PARTITIONED_BY": lambda self: self._parse_partitioned_by(),
     757        "PRIMARY KEY": lambda self: self._parse_primary_key(in_props=True),
     758        "RANGE": lambda self: self._parse_dict_range(this="RANGE"),
     759        "READS": lambda self: self._parse_reads_property(),
     760        "REMOTE": lambda self: self._parse_remote_with_connection(),
     761        "RETURNS": lambda self: self._parse_returns(),
     762        "ROW": lambda self: self._parse_row(),
     763        "ROW_FORMAT": lambda self: self._parse_property_assignment(exp.RowFormatProperty),
     764        "SAMPLE": lambda self: self.expression(
     765            exp.SampleProperty, this=self._match_text_seq("BY") and self._parse_bitwise()
     766        ),
     767        "SET": lambda self: self.expression(exp.SetProperty, multi=False),
     768        "SETTINGS": lambda self: self.expression(
     769            exp.SettingsProperty, expressions=self._parse_csv(self._parse_set_item)
     770        ),
     771        "SORTKEY": lambda self: self._parse_sortkey(),
     772        "SOURCE": lambda self: self._parse_dict_property(this="SOURCE"),
     773        "STABLE": lambda self: self.expression(
     774            exp.StabilityProperty, this=exp.Literal.string("STABLE")
     775        ),
     776        "STORED": lambda self: self._parse_stored(),
     777        "SYSTEM_VERSIONING": lambda self: self._parse_system_versioning_property(),
     778        "TBLPROPERTIES": lambda self: self._parse_wrapped_csv(self._parse_property),
     779        "TEMP": lambda self: self.expression(exp.TemporaryProperty),
     780        "TEMPORARY": lambda self: self.expression(exp.TemporaryProperty),
     781        "TO": lambda self: self._parse_to_table(),
     782        "TRANSIENT": lambda self: self.expression(exp.TransientProperty),
     783        "TRANSFORM": lambda self: self.expression(
     784            exp.TransformModelProperty, expressions=self._parse_wrapped_csv(self._parse_expression)
     785        ),
     786        "TTL": lambda self: self._parse_ttl(),
     787        "USING": lambda self: self._parse_property_assignment(exp.FileFormatProperty),
     788        "VOLATILE": lambda self: self._parse_volatile_property(),
     789        "WITH": lambda self: self._parse_with_property(),
     790    }
     791
     792    CONSTRAINT_PARSERS = {
     793        "AUTOINCREMENT": lambda self: self._parse_auto_increment(),
     794        "AUTO_INCREMENT": lambda self: self._parse_auto_increment(),
     795        "CASESPECIFIC": lambda self: self.expression(exp.CaseSpecificColumnConstraint, not_=False),
     796        "CHARACTER SET": lambda self: self.expression(
     797            exp.CharacterSetColumnConstraint, this=self._parse_var_or_string()
     798        ),
     799        "CHECK": lambda self: self.expression(
     800            exp.CheckColumnConstraint, this=self._parse_wrapped(self._parse_conjunction)
     801        ),
     802        "COLLATE": lambda self: self.expression(
     803            exp.CollateColumnConstraint, this=self._parse_var()
     804        ),
     805        "COMMENT": lambda self: self.expression(
     806            exp.CommentColumnConstraint, this=self._parse_string()
     807        ),
     808        "COMPRESS": lambda self: self._parse_compress(),
     809        "CLUSTERED": lambda self: self.expression(
     810            exp.ClusteredColumnConstraint, this=self._parse_wrapped_csv(self._parse_ordered)
     811        ),
     812        "NONCLUSTERED": lambda self: self.expression(
     813            exp.NonClusteredColumnConstraint, this=self._parse_wrapped_csv(self._parse_ordered)
     814        ),
     815        "DEFAULT": lambda self: self.expression(
     816            exp.DefaultColumnConstraint, this=self._parse_bitwise()
     817        ),
     818        "ENCODE": lambda self: self.expression(exp.EncodeColumnConstraint, this=self._parse_var()),
     819        "FOREIGN KEY": lambda self: self._parse_foreign_key(),
     820        "FORMAT": lambda self: self.expression(
     821            exp.DateFormatColumnConstraint, this=self._parse_var_or_string()
     822        ),
     823        "GENERATED": lambda self: self._parse_generated_as_identity(),
     824        "IDENTITY": lambda self: self._parse_auto_increment(),
     825        "INLINE": lambda self: self._parse_inline(),
     826        "LIKE": lambda self: self._parse_create_like(),
     827        "NOT": lambda self: self._parse_not_constraint(),
     828        "NULL": lambda self: self.expression(exp.NotNullColumnConstraint, allow_null=True),
     829        "ON": lambda self: (
     830            self._match(TokenType.UPDATE)
     831            and self.expression(exp.OnUpdateColumnConstraint, this=self._parse_function())
     832        )
     833        or self.expression(exp.OnProperty, this=self._parse_id_var()),
     834        "PATH": lambda self: self.expression(exp.PathColumnConstraint, this=self._parse_string()),
     835        "PERIOD": lambda self: self._parse_period_for_system_time(),
     836        "PRIMARY KEY": lambda self: self._parse_primary_key(),
     837        "REFERENCES": lambda self: self._parse_references(match=False),
     838        "TITLE": lambda self: self.expression(
     839            exp.TitleColumnConstraint, this=self._parse_var_or_string()
     840        ),
     841        "TTL": lambda self: self.expression(exp.MergeTreeTTL, expressions=[self._parse_bitwise()]),
     842        "UNIQUE": lambda self: self._parse_unique(),
     843        "UPPERCASE": lambda self: self.expression(exp.UppercaseColumnConstraint),
     844        "WITH": lambda self: self.expression(
     845            exp.Properties, expressions=self._parse_wrapped_csv(self._parse_property)
     846        ),
     847    }
     848
     849    ALTER_PARSERS = {
     850        "ADD": lambda self: self._parse_alter_table_add(),
     851        "ALTER": lambda self: self._parse_alter_table_alter(),
     852        "CLUSTER BY": lambda self: self._parse_cluster(wrapped=True),
     853        "DELETE": lambda self: self.expression(exp.Delete, where=self._parse_where()),
     854        "DROP": lambda self: self._parse_alter_table_drop(),
     855        "RENAME": lambda self: self._parse_alter_table_rename(),
     856    }
     857
     858    SCHEMA_UNNAMED_CONSTRAINTS = {"CHECK", "FOREIGN KEY", "LIKE", "PRIMARY KEY", "UNIQUE", "PERIOD"}
     859
     860    NO_PAREN_FUNCTION_PARSERS = {
     861        "ANY": lambda self: self.expression(exp.Any, this=self._parse_bitwise()),
     862        "CASE": lambda self: self._parse_case(),
     863        "IF": lambda self: self._parse_if(),
     864        "NEXT": lambda self: self._parse_next_value_for(),
     865    }
     866
     867    INVALID_FUNC_NAME_TOKENS = {
     868        TokenType.IDENTIFIER,
     869        TokenType.STRING,
     870    }
     871
     872    FUNCTIONS_WITH_ALIASED_ARGS = {"STRUCT"}
     873
     874    FUNCTION_PARSERS = {
     875        "ANY_VALUE": lambda self: self._parse_any_value(),
     876        "CAST": lambda self: self._parse_cast(self.STRICT_CAST),
     877        "CONVERT": lambda self: self._parse_convert(self.STRICT_CAST),
     878        "DECODE": lambda self: self._parse_decode(),
     879        "EXTRACT": lambda self: self._parse_extract(),
     880        "JSON_OBJECT": lambda self: self._parse_json_object(),
     881        "JSON_OBJECTAGG": lambda self: self._parse_json_object(agg=True),
     882        "JSON_TABLE": lambda self: self._parse_json_table(),
     883        "MATCH": lambda self: self._parse_match_against(),
     884        "OPENJSON": lambda self: self._parse_open_json(),
     885        "POSITION": lambda self: self._parse_position(),
     886        "PREDICT": lambda self: self._parse_predict(),
     887        "SAFE_CAST": lambda self: self._parse_cast(False, safe=True),
     888        "STRING_AGG": lambda self: self._parse_string_agg(),
     889        "SUBSTRING": lambda self: self._parse_substring(),
     890        "TRIM": lambda self: self._parse_trim(),
     891        "TRY_CAST": lambda self: self._parse_cast(False, safe=True),
     892        "TRY_CONVERT": lambda self: self._parse_convert(False, safe=True),
     893    }
     894
     895    QUERY_MODIFIER_PARSERS = {
     896        TokenType.MATCH_RECOGNIZE: lambda self: ("match", self._parse_match_recognize()),
     897        TokenType.WHERE: lambda self: ("where", self._parse_where()),
     898        TokenType.GROUP_BY: lambda self: ("group", self._parse_group()),
     899        TokenType.HAVING: lambda self: ("having", self._parse_having()),
     900        TokenType.QUALIFY: lambda self: ("qualify", self._parse_qualify()),
     901        TokenType.WINDOW: lambda self: ("windows", self._parse_window_clause()),
     902        TokenType.ORDER_BY: lambda self: ("order", self._parse_order()),
     903        TokenType.LIMIT: lambda self: ("limit", self._parse_limit()),
     904        TokenType.FETCH: lambda self: ("limit", self._parse_limit()),
     905        TokenType.OFFSET: lambda self: ("offset", self._parse_offset()),
     906        TokenType.FOR: lambda self: ("locks", self._parse_locks()),
     907        TokenType.LOCK: lambda self: ("locks", self._parse_locks()),
     908        TokenType.TABLE_SAMPLE: lambda self: ("sample", self._parse_table_sample(as_modifier=True)),
     909        TokenType.USING: lambda self: ("sample", self._parse_table_sample(as_modifier=True)),
     910        TokenType.CLUSTER_BY: lambda self: (
     911            "cluster",
     912            self._parse_sort(exp.Cluster, TokenType.CLUSTER_BY),
     913        ),
     914        TokenType.DISTRIBUTE_BY: lambda self: (
     915            "distribute",
     916            self._parse_sort(exp.Distribute, TokenType.DISTRIBUTE_BY),
     917        ),
     918        TokenType.SORT_BY: lambda self: ("sort", self._parse_sort(exp.Sort, TokenType.SORT_BY)),
     919        TokenType.CONNECT_BY: lambda self: ("connect", self._parse_connect(skip_start_token=True)),
     920        TokenType.START_WITH: lambda self: ("connect", self._parse_connect()),
     921    }
     922
     923    SET_PARSERS = {
     924        "GLOBAL": lambda self: self._parse_set_item_assignment("GLOBAL"),
     925        "LOCAL": lambda self: self._parse_set_item_assignment("LOCAL"),
     926        "SESSION": lambda self: self._parse_set_item_assignment("SESSION"),
     927        "TRANSACTION": lambda self: self._parse_set_transaction(),
     928    }
     929
     930    SHOW_PARSERS: t.Dict[str, t.Callable] = {}
     931
     932    TYPE_LITERAL_PARSERS = {
     933        exp.DataType.Type.JSON: lambda self, this, _: self.expression(exp.ParseJSON, this=this),
     934    }
     935
     936    MODIFIABLES = (exp.Subquery, exp.Subqueryable, exp.Table)
     937
     938    DDL_SELECT_TOKENS = {TokenType.SELECT, TokenType.WITH, TokenType.L_PAREN}
     939
     940    PRE_VOLATILE_TOKENS = {TokenType.CREATE, TokenType.REPLACE, TokenType.UNIQUE}
     941
     942    TRANSACTION_KIND = {"DEFERRED", "IMMEDIATE", "EXCLUSIVE"}
     943    TRANSACTION_CHARACTERISTICS = {
     944        "ISOLATION LEVEL REPEATABLE READ",
     945        "ISOLATION LEVEL READ COMMITTED",
     946        "ISOLATION LEVEL READ UNCOMMITTED",
     947        "ISOLATION LEVEL SERIALIZABLE",
     948        "READ WRITE",
     949        "READ ONLY",
     950    }
     951
     952    INSERT_ALTERNATIVES = {"ABORT", "FAIL", "IGNORE", "REPLACE", "ROLLBACK"}
     953
     954    CLONE_KEYWORDS = {"CLONE", "COPY"}
     955    HISTORICAL_DATA_KIND = {"TIMESTAMP", "OFFSET", "STATEMENT", "STREAM"}
     956
     957    OPCLASS_FOLLOW_KEYWORDS = {"ASC", "DESC", "NULLS"}
     958    OPTYPE_FOLLOW_TOKENS = {TokenType.COMMA, TokenType.R_PAREN}
     959
     960    TABLE_INDEX_HINT_TOKENS = {TokenType.FORCE, TokenType.IGNORE, TokenType.USE}
     961
     962    WINDOW_ALIAS_TOKENS = ID_VAR_TOKENS - {TokenType.ROWS}
     963    WINDOW_BEFORE_PAREN_TOKENS = {TokenType.OVER}
     964    WINDOW_SIDES = {"FOLLOWING", "PRECEDING"}
     965
     966    JSON_KEY_VALUE_SEPARATOR_TOKENS = {TokenType.COLON, TokenType.COMMA, TokenType.IS}
     967
     968    FETCH_TOKENS = ID_VAR_TOKENS - {TokenType.ROW, TokenType.ROWS, TokenType.PERCENT}
     969
     970    ADD_CONSTRAINT_TOKENS = {TokenType.CONSTRAINT, TokenType.PRIMARY_KEY, TokenType.FOREIGN_KEY}
     971
     972    DISTINCT_TOKENS = {TokenType.DISTINCT}
     973
     974    NULL_TOKENS = {TokenType.NULL}
     975
     976    UNNEST_OFFSET_ALIAS_TOKENS = ID_VAR_TOKENS - SET_OPERATIONS
     977
     978    STRICT_CAST = True
     979
     980    PREFIXED_PIVOT_COLUMNS = False
     981    IDENTIFY_PIVOT_STRINGS = False
     982
     983    LOG_DEFAULTS_TO_LN = False
     984
     985    # Whether or not ADD is present for each column added by ALTER TABLE
     986    ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN = True
     987
     988    # Whether or not the table sample clause expects CSV syntax
     989    TABLESAMPLE_CSV = False
     990
     991    # Whether or not the SET command needs a delimiter (e.g. "=") for assignments
     992    SET_REQUIRES_ASSIGNMENT_DELIMITER = True
     993
     994    # Whether the TRIM function expects the characters to trim as its first argument
     995    TRIM_PATTERN_FIRST = False
     996
     997    # Whether or not string aliases are supported `SELECT COUNT(*) 'count'`
     998    STRING_ALIASES = False
     999
    1000    # Whether query modifiers such as LIMIT are attached to the UNION node (vs its right operand)
    1001    MODIFIERS_ATTACHED_TO_UNION = True
    1002    UNION_MODIFIERS = {"order", "limit", "offset"}
    1003
    1004    # parses no parenthesis if statements as commands
    1005    NO_PAREN_IF_COMMANDS = True
    1006
    1007    __slots__ = (
    1008        "error_level",
    1009        "error_message_context",
    1010        "max_errors",
    1011        "dialect",
    1012        "sql",
    1013        "errors",
    1014        "_tokens",
    1015        "_index",
    1016        "_curr",
    1017        "_next",
    1018        "_prev",
    1019        "_prev_comments",
    1020    )
    1021
    1022    # Autofilled
    1023    SHOW_TRIE: t.Dict = {}
    1024    SET_TRIE: t.Dict = {}
    1025
    1026    def __init__(
    1027        self,
    1028        error_level: t.Optional[ErrorLevel] = None,
    1029        error_message_context: int = 100,
    1030        max_errors: int = 3,
    1031        dialect: DialectType = None,
    1032    ):
    1033        from sqlglot.dialects import Dialect
    1034
    1035        self.error_level = error_level or ErrorLevel.IMMEDIATE
    1036        self.error_message_context = error_message_context
    1037        self.max_errors = max_errors
    1038        self.dialect = Dialect.get_or_raise(dialect)
    1039        self.reset()
    1040
    1041    def reset(self):
    1042        self.sql = ""
    1043        self.errors = []
    1044        self._tokens = []
    1045        self._index = 0
    1046        self._curr = None
    1047        self._next = None
    1048        self._prev = None
    1049        self._prev_comments = None
    1050
    1051    def parse(
    1052        self, raw_tokens: t.List[Token], sql: t.Optional[str] = None
    1053    ) -> t.List[t.Optional[exp.Expression]]:
    1054        """
    1055        Parses a list of tokens and returns a list of syntax trees, one tree
    1056        per parsed SQL statement.
    1057
    1058        Args:
    1059            raw_tokens: The list of tokens.
    1060            sql: The original SQL string, used to produce helpful debug messages.
    1061
    1062        Returns:
    1063            The list of the produced syntax trees.
    1064        """
    1065        return self._parse(
    1066            parse_method=self.__class__._parse_statement, raw_tokens=raw_tokens, sql=sql
    1067        )
    1068
    1069    def parse_into(
    1070        self,
    1071        expression_types: exp.IntoType,
    1072        raw_tokens: t.List[Token],
    1073        sql: t.Optional[str] = None,
    1074    ) -> t.List[t.Optional[exp.Expression]]:
    1075        """
    1076        Parses a list of tokens into a given Expression type. If a collection of Expression
    1077        types is given instead, this method will try to parse the token list into each one
    1078        of them, stopping at the first for which the parsing succeeds.
    1079
    1080        Args:
    1081            expression_types: The expression type(s) to try and parse the token list into.
    1082            raw_tokens: The list of tokens.
    1083            sql: The original SQL string, used to produce helpful debug messages.
    1084
    1085        Returns:
    1086            The target Expression.
    1087        """
    1088        errors = []
    1089        for expression_type in ensure_list(expression_types):
    1090            parser = self.EXPRESSION_PARSERS.get(expression_type)
    1091            if not parser:
    1092                raise TypeError(f"No parser registered for {expression_type}")
    1093
    1094            try:
    1095                return self._parse(parser, raw_tokens, sql)
    1096            except ParseError as e:
    1097                e.errors[0]["into_expression"] = expression_type
    1098                errors.append(e)
    1099
    1100        raise ParseError(
    1101            f"Failed to parse '{sql or raw_tokens}' into {expression_types}",
    1102            errors=merge_errors(errors),
    1103        ) from errors[-1]
    1104
    1105    def _parse(
    1106        self,
    1107        parse_method: t.Callable[[Parser], t.Optional[exp.Expression]],
    1108        raw_tokens: t.List[Token],
    1109        sql: t.Optional[str] = None,
    1110    ) -> t.List[t.Optional[exp.Expression]]:
    1111        self.reset()
    1112        self.sql = sql or ""
    1113
    1114        total = len(raw_tokens)
    1115        chunks: t.List[t.List[Token]] = [[]]
    1116
    1117        for i, token in enumerate(raw_tokens):
    1118            if token.token_type == TokenType.SEMICOLON:
    1119                if i < total - 1:
    1120                    chunks.append([])
    1121            else:
    1122                chunks[-1].append(token)
    1123
    1124        expressions = []
    1125
    1126        for tokens in chunks:
    1127            self._index = -1
    1128            self._tokens = tokens
    1129            self._advance()
    1130
    1131            expressions.append(parse_method(self))
    1132
    1133            if self._index < len(self._tokens):
    1134                self.raise_error("Invalid expression / Unexpected token")
    1135
    1136            self.check_errors()
    1137
    1138        return expressions
    1139
    1140    def check_errors(self) -> None:
    1141        """Logs or raises any found errors, depending on the chosen error level setting."""
    1142        if self.error_level == ErrorLevel.WARN:
    1143            for error in self.errors:
    1144                logger.error(str(error))
    1145        elif self.error_level == ErrorLevel.RAISE and self.errors:
    1146            raise ParseError(
    1147                concat_messages(self.errors, self.max_errors),
    1148                errors=merge_errors(self.errors),
    1149            )
    1150
    1151    def raise_error(self, message: str, token: t.Optional[Token] = None) -> None:
    1152        """
    1153        Appends an error in the list of recorded errors or raises it, depending on the chosen
    1154        error level setting.
    1155        """
    1156        token = token or self._curr or self._prev or Token.string("")
    1157        start = token.start
    1158        end = token.end + 1
    1159        start_context = self.sql[max(start - self.error_message_context, 0) : start]
    1160        highlight = self.sql[start:end]
    1161        end_context = self.sql[end : end + self.error_message_context]
    1162
    1163        error = ParseError.new(
    1164            f"{message}. Line {token.line}, Col: {token.col}.\n"
    1165            f"  {start_context}\033[4m{highlight}\033[0m{end_context}",
    1166            description=message,
    1167            line=token.line,
    1168            col=token.col,
    1169            start_context=start_context,
    1170            highlight=highlight,
    1171            end_context=end_context,
    1172        )
    1173
    1174        if self.error_level == ErrorLevel.IMMEDIATE:
    1175            raise error
    1176
    1177        self.errors.append(error)
    1178
    1179    def expression(
    1180        self, exp_class: t.Type[E], comments: t.Optional[t.List[str]] = None, **kwargs
    1181    ) -> E:
    1182        """
    1183        Creates a new, validated Expression.
    1184
    1185        Args:
    1186            exp_class: The expression class to instantiate.
    1187            comments: An optional list of comments to attach to the expression.
    1188            kwargs: The arguments to set for the expression along with their respective values.
    1189
    1190        Returns:
    1191            The target expression.
    1192        """
    1193        instance = exp_class(**kwargs)
    1194        instance.add_comments(comments) if comments else self._add_comments(instance)
    1195        return self.validate_expression(instance)
    1196
    1197    def _add_comments(self, expression: t.Optional[exp.Expression]) -> None:
    1198        if expression and self._prev_comments:
    1199            expression.add_comments(self._prev_comments)
    1200            self._prev_comments = None
    1201
    1202    def validate_expression(self, expression: E, args: t.Optional[t.List] = None) -> E:
    1203        """
    1204        Validates an Expression, making sure that all its mandatory arguments are set.
    1205
    1206        Args:
    1207            expression: The expression to validate.
    1208            args: An optional list of items that was used to instantiate the expression, if it's a Func.
    1209
    1210        Returns:
    1211            The validated expression.
    1212        """
    1213        if self.error_level != ErrorLevel.IGNORE:
    1214            for error_message in expression.error_messages(args):
    1215                self.raise_error(error_message)
    1216
    1217        return expression
    1218
    1219    def _find_sql(self, start: Token, end: Token) -> str:
    1220        return self.sql[start.start : end.end + 1]
    1221
    1222    def _is_connected(self) -> bool:
    1223        return self._prev and self._curr and self._prev.end + 1 == self._curr.start
    1224
    1225    def _advance(self, times: int = 1) -> None:
    1226        self._index += times
    1227        self._curr = seq_get(self._tokens, self._index)
    1228        self._next = seq_get(self._tokens, self._index + 1)
    1229
    1230        if self._index > 0:
    1231            self._prev = self._tokens[self._index - 1]
    1232            self._prev_comments = self._prev.comments
    1233        else:
    1234            self._prev = None
    1235            self._prev_comments = None
    1236
    1237    def _retreat(self, index: int) -> None:
    1238        if index != self._index:
    1239            self._advance(index - self._index)
    1240
    1241    def _warn_unsupported(self) -> None:
    1242        if len(self._tokens) <= 1:
    1243            return
    1244
    1245        # We use _find_sql because self.sql may comprise multiple chunks, and we're only
    1246        # interested in emitting a warning for the one being currently processed.
    1247        sql = self._find_sql(self._tokens[0], self._tokens[-1])[: self.error_message_context]
    1248
    1249        logger.warning(
    1250            f"'{sql}' contains unsupported syntax. Falling back to parsing as a 'Command'."
    1251        )
    1252
    1253    def _parse_command(self) -> exp.Command:
    1254        self._warn_unsupported()
    1255        return self.expression(
    1256            exp.Command, this=self._prev.text.upper(), expression=self._parse_string()
    1257        )
    1258
    1259    def _parse_comment(self, allow_exists: bool = True) -> exp.Expression:
    1260        start = self._prev
    1261        exists = self._parse_exists() if allow_exists else None
    1262
    1263        self._match(TokenType.ON)
    1264
    1265        kind = self._match_set(self.CREATABLES) and self._prev
    1266        if not kind:
    1267            return self._parse_as_command(start)
    1268
    1269        if kind.token_type in (TokenType.FUNCTION, TokenType.PROCEDURE):
    1270            this = self._parse_user_defined_function(kind=kind.token_type)
    1271        elif kind.token_type == TokenType.TABLE:
    1272            this = self._parse_table(alias_tokens=self.COMMENT_TABLE_ALIAS_TOKENS)
    1273        elif kind.token_type == TokenType.COLUMN:
    1274            this = self._parse_column()
    1275        else:
    1276            this = self._parse_id_var()
    1277
    1278        self._match(TokenType.IS)
    1279
    1280        return self.expression(
    1281            exp.Comment, this=this, kind=kind.text, expression=self._parse_string(), exists=exists
    1282        )
    1283
    1284    def _parse_to_table(
    1285        self,
    1286    ) -> exp.ToTableProperty:
    1287        table = self._parse_table_parts(schema=True)
    1288        return self.expression(exp.ToTableProperty, this=table)
    1289
    1290    # https://clickhouse.com/docs/en/engines/table-engines/mergetree-family/mergetree#mergetree-table-ttl
    1291    def _parse_ttl(self) -> exp.Expression:
    1292        def _parse_ttl_action() -> t.Optional[exp.Expression]:
    1293            this = self._parse_bitwise()
    1294
    1295            if self._match_text_seq("DELETE"):
    1296                return self.expression(exp.MergeTreeTTLAction, this=this, delete=True)
    1297            if self._match_text_seq("RECOMPRESS"):
    1298                return self.expression(
    1299                    exp.MergeTreeTTLAction, this=this, recompress=self._parse_bitwise()
    1300                )
    1301            if self._match_text_seq("TO", "DISK"):
    1302                return self.expression(
    1303                    exp.MergeTreeTTLAction, this=this, to_disk=self._parse_string()
    1304                )
    1305            if self._match_text_seq("TO", "VOLUME"):
    1306                return self.expression(
    1307                    exp.MergeTreeTTLAction, this=this, to_volume=self._parse_string()
    1308                )
    1309
    1310            return this
    1311
    1312        expressions = self._parse_csv(_parse_ttl_action)
    1313        where = self._parse_where()
    1314        group = self._parse_group()
    1315
    1316        aggregates = None
    1317        if group and self._match(TokenType.SET):
    1318            aggregates = self._parse_csv(self._parse_set_item)
    1319
    1320        return self.expression(
    1321            exp.MergeTreeTTL,
    1322            expressions=expressions,
    1323            where=where,
    1324            group=group,
    1325            aggregates=aggregates,
    1326        )
    1327
    1328    def _parse_statement(self) -> t.Optional[exp.Expression]:
    1329        if self._curr is None:
    1330            return None
    1331
    1332        if self._match_set(self.STATEMENT_PARSERS):
    1333            return self.STATEMENT_PARSERS[self._prev.token_type](self)
    1334
    1335        if self._match_set(Tokenizer.COMMANDS):
    1336            return self._parse_command()
    1337
    1338        expression = self._parse_expression()
    1339        expression = self._parse_set_operations(expression) if expression else self._parse_select()
    1340        return self._parse_query_modifiers(expression)
    1341
    1342    def _parse_drop(self, exists: bool = False) -> exp.Drop | exp.Command:
    1343        start = self._prev
    1344        temporary = self._match(TokenType.TEMPORARY)
    1345        materialized = self._match_text_seq("MATERIALIZED")
    1346
    1347        kind = self._match_set(self.CREATABLES) and self._prev.text
    1348        if not kind:
    1349            return self._parse_as_command(start)
    1350
    1351        return self.expression(
    1352            exp.Drop,
    1353            comments=start.comments,
    1354            exists=exists or self._parse_exists(),
    1355            this=self._parse_table(
    1356                schema=True, is_db_reference=self._prev.token_type == TokenType.SCHEMA
    1357            ),
    1358            kind=kind,
    1359            temporary=temporary,
    1360            materialized=materialized,
    1361            cascade=self._match_text_seq("CASCADE"),
    1362            constraints=self._match_text_seq("CONSTRAINTS"),
    1363            purge=self._match_text_seq("PURGE"),
    1364        )
    1365
    1366    def _parse_exists(self, not_: bool = False) -> t.Optional[bool]:
    1367        return (
    1368            self._match_text_seq("IF")
    1369            and (not not_ or self._match(TokenType.NOT))
    1370            and self._match(TokenType.EXISTS)
    1371        )
    1372
    1373    def _parse_create(self) -> exp.Create | exp.Command:
    1374        # Note: this can't be None because we've matched a statement parser
    1375        start = self._prev
    1376        comments = self._prev_comments
    1377
    1378        replace = (
    1379            start.token_type == TokenType.REPLACE
    1380            or self._match_pair(TokenType.OR, TokenType.REPLACE)
    1381            or self._match_pair(TokenType.OR, TokenType.ALTER)
    1382        )
    1383        unique = self._match(TokenType.UNIQUE)
    1384
    1385        if self._match_pair(TokenType.TABLE, TokenType.FUNCTION, advance=False):
    1386            self._advance()
    1387
    1388        properties = None
    1389        create_token = self._match_set(self.CREATABLES) and self._prev
    1390
    1391        if not create_token:
    1392            # exp.Properties.Location.POST_CREATE
    1393            properties = self._parse_properties()
    1394            create_token = self._match_set(self.CREATABLES) and self._prev
    1395
    1396            if not properties or not create_token:
    1397                return self._parse_as_command(start)
    1398
    1399        exists = self._parse_exists(not_=True)
    1400        this = None
    1401        expression: t.Optional[exp.Expression] = None
    1402        indexes = None
    1403        no_schema_binding = None
    1404        begin = None
    1405        end = None
    1406        clone = None
    1407
    1408        def extend_props(temp_props: t.Optional[exp.Properties]) -> None:
    1409            nonlocal properties
    1410            if properties and temp_props:
    1411                properties.expressions.extend(temp_props.expressions)
    1412            elif temp_props:
    1413                properties = temp_props
    1414
    1415        if create_token.token_type in (TokenType.FUNCTION, TokenType.PROCEDURE):
    1416            this = self._parse_user_defined_function(kind=create_token.token_type)
    1417
    1418            # exp.Properties.Location.POST_SCHEMA ("schema" here is the UDF's type signature)
    1419            extend_props(self._parse_properties())
    1420
    1421            expression = self._match(TokenType.ALIAS) and self._parse_heredoc()
    1422
    1423            if not expression:
    1424                if self._match(TokenType.COMMAND):
    1425                    expression = self._parse_as_command(self._prev)
    1426                else:
    1427                    begin = self._match(TokenType.BEGIN)
    1428                    return_ = self._match_text_seq("RETURN")
    1429
    1430                    if self._match(TokenType.STRING, advance=False):
    1431                        # Takes care of BigQuery's JavaScript UDF definitions that end in an OPTIONS property
    1432                        # # https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_function_statement
    1433                        expression = self._parse_string()
    1434                        extend_props(self._parse_properties())
    1435                    else:
    1436                        expression = self._parse_statement()
    1437
    1438                    end = self._match_text_seq("END")
    1439
    1440                    if return_:
    1441                        expression = self.expression(exp.Return, this=expression)
    1442        elif create_token.token_type == TokenType.INDEX:
    1443            this = self._parse_index(index=self._parse_id_var())
    1444        elif create_token.token_type in self.DB_CREATABLES:
    1445            table_parts = self._parse_table_parts(
    1446                schema=True, is_db_reference=create_token.token_type == TokenType.SCHEMA
    1447            )
    1448
    1449            # exp.Properties.Location.POST_NAME
    1450            self._match(TokenType.COMMA)
    1451            extend_props(self._parse_properties(before=True))
    1452
    1453            this = self._parse_schema(this=table_parts)
    1454
    1455            # exp.Properties.Location.POST_SCHEMA and POST_WITH
    1456            extend_props(self._parse_properties())
    1457
    1458            self._match(TokenType.ALIAS)
    1459            if not self._match_set(self.DDL_SELECT_TOKENS, advance=False):
    1460                # exp.Properties.Location.POST_ALIAS
    1461                extend_props(self._parse_properties())
    1462
    1463            expression = self._parse_ddl_select()
    1464
    1465            if create_token.token_type == TokenType.TABLE:
    1466                # exp.Properties.Location.POST_EXPRESSION
    1467                extend_props(self._parse_properties())
    1468
    1469                indexes = []
    1470                while True:
    1471                    index = self._parse_index()
    1472
    1473                    # exp.Properties.Location.POST_INDEX
    1474                    extend_props(self._parse_properties())
    1475
    1476                    if not index:
    1477                        break
    1478                    else:
    1479                        self._match(TokenType.COMMA)
    1480                        indexes.append(index)
    1481            elif create_token.token_type == TokenType.VIEW:
    1482                if self._match_text_seq("WITH", "NO", "SCHEMA", "BINDING"):
    1483                    no_schema_binding = True
    1484
    1485            shallow = self._match_text_seq("SHALLOW")
    1486
    1487            if self._match_texts(self.CLONE_KEYWORDS):
    1488                copy = self._prev.text.lower() == "copy"
    1489                clone = self.expression(
    1490                    exp.Clone, this=self._parse_table(schema=True), shallow=shallow, copy=copy
    1491                )
    1492
    1493        if self._curr:
    1494            return self._parse_as_command(start)
    1495
    1496        return self.expression(
    1497            exp.Create,
    1498            comments=comments,
    1499            this=this,
    1500            kind=create_token.text.upper(),
    1501            replace=replace,
    1502            unique=unique,
    1503            expression=expression,
    1504            exists=exists,
    1505            properties=properties,
    1506            indexes=indexes,
    1507            no_schema_binding=no_schema_binding,
    1508            begin=begin,
    1509            end=end,
    1510            clone=clone,
    1511        )
    1512
    1513    def _parse_property_before(self) -> t.Optional[exp.Expression]:
    1514        # only used for teradata currently
    1515        self._match(TokenType.COMMA)
    1516
    1517        kwargs = {
    1518            "no": self._match_text_seq("NO"),
    1519            "dual": self._match_text_seq("DUAL"),
    1520            "before": self._match_text_seq("BEFORE"),
    1521            "default": self._match_text_seq("DEFAULT"),
    1522            "local": (self._match_text_seq("LOCAL") and "LOCAL")
    1523            or (self._match_text_seq("NOT", "LOCAL") and "NOT LOCAL"),
    1524            "after": self._match_text_seq("AFTER"),
    1525            "minimum": self._match_texts(("MIN", "MINIMUM")),
    1526            "maximum": self._match_texts(("MAX", "MAXIMUM")),
    1527        }
    1528
    1529        if self._match_texts(self.PROPERTY_PARSERS):
    1530            parser = self.PROPERTY_PARSERS[self._prev.text.upper()]
    1531            try:
    1532                return parser(self, **{k: v for k, v in kwargs.items() if v})
    1533            except TypeError:
    1534                self.raise_error(f"Cannot parse property '{self._prev.text}'")
    1535
    1536        return None
    1537
    1538    def _parse_property(self) -> t.Optional[exp.Expression]:
    1539        if self._match_texts(self.PROPERTY_PARSERS):
    1540            return self.PROPERTY_PARSERS[self._prev.text.upper()](self)
    1541
    1542        if self._match(TokenType.DEFAULT) and self._match_texts(self.PROPERTY_PARSERS):
    1543            return self.PROPERTY_PARSERS[self._prev.text.upper()](self, default=True)
    1544
    1545        if self._match_text_seq("COMPOUND", "SORTKEY"):
    1546            return self._parse_sortkey(compound=True)
    1547
    1548        if self._match_text_seq("SQL", "SECURITY"):
    1549            return self.expression(exp.SqlSecurityProperty, definer=self._match_text_seq("DEFINER"))
    1550
    1551        index = self._index
    1552        key = self._parse_column()
    1553
    1554        if not self._match(TokenType.EQ):
    1555            self._retreat(index)
    1556            return None
    1557
    1558        return self.expression(
    1559            exp.Property,
    1560            this=key.to_dot() if isinstance(key, exp.Column) else key,
    1561            value=self._parse_column() or self._parse_var(any_token=True),
    1562        )
    1563
    1564    def _parse_stored(self) -> exp.FileFormatProperty:
    1565        self._match(TokenType.ALIAS)
    1566
    1567        input_format = self._parse_string() if self._match_text_seq("INPUTFORMAT") else None
    1568        output_format = self._parse_string() if self._match_text_seq("OUTPUTFORMAT") else None
    1569
    1570        return self.expression(
    1571            exp.FileFormatProperty,
    1572            this=(
    1573                self.expression(
    1574                    exp.InputOutputFormat, input_format=input_format, output_format=output_format
    1575                )
    1576                if input_format or output_format
    1577                else self._parse_var_or_string() or self._parse_number() or self._parse_id_var()
    1578            ),
    1579        )
    1580
    1581    def _parse_property_assignment(self, exp_class: t.Type[E], **kwargs: t.Any) -> E:
    1582        self._match(TokenType.EQ)
    1583        self._match(TokenType.ALIAS)
    1584        return self.expression(exp_class, this=self._parse_field(), **kwargs)
    1585
    1586    def _parse_properties(self, before: t.Optional[bool] = None) -> t.Optional[exp.Properties]:
    1587        properties = []
    1588        while True:
    1589            if before:
    1590                prop = self._parse_property_before()
    1591            else:
    1592                prop = self._parse_property()
    1593
    1594            if not prop:
    1595                break
    1596            for p in ensure_list(prop):
    1597                properties.append(p)
    1598
    1599        if properties:
    1600            return self.expression(exp.Properties, expressions=properties)
    1601
    1602        return None
    1603
    1604    def _parse_fallback(self, no: bool = False) -> exp.FallbackProperty:
    1605        return self.expression(
    1606            exp.FallbackProperty, no=no, protection=self._match_text_seq("PROTECTION")
    1607        )
    1608
    1609    def _parse_volatile_property(self) -> exp.VolatileProperty | exp.StabilityProperty:
    1610        if self._index >= 2:
    1611            pre_volatile_token = self._tokens[self._index - 2]
    1612        else:
    1613            pre_volatile_token = None
    1614
    1615        if pre_volatile_token and pre_volatile_token.token_type in self.PRE_VOLATILE_TOKENS:
    1616            return exp.VolatileProperty()
    1617
    1618        return self.expression(exp.StabilityProperty, this=exp.Literal.string("VOLATILE"))
    1619
    1620    def _parse_system_versioning_property(self) -> exp.WithSystemVersioningProperty:
    1621        self._match_pair(TokenType.EQ, TokenType.ON)
    1622
    1623        prop = self.expression(exp.WithSystemVersioningProperty)
    1624        if self._match(TokenType.L_PAREN):
    1625            self._match_text_seq("HISTORY_TABLE", "=")
    1626            prop.set("this", self._parse_table_parts())
    1627
    1628            if self._match(TokenType.COMMA):
    1629                self._match_text_seq("DATA_CONSISTENCY_CHECK", "=")
    1630                prop.set("expression", self._advance_any() and self._prev.text.upper())
    1631
    1632            self._match_r_paren()
    1633
    1634        return prop
    1635
    1636    def _parse_with_property(
    1637        self,
    1638    ) -> t.Optional[exp.Expression] | t.List[exp.Expression]:
    1639        if self._match(TokenType.L_PAREN, advance=False):
    1640            return self._parse_wrapped_csv(self._parse_property)
    1641
    1642        if self._match_text_seq("JOURNAL"):
    1643            return self._parse_withjournaltable()
    1644
    1645        if self._match_text_seq("DATA"):
    1646            return self._parse_withdata(no=False)
    1647        elif self._match_text_seq("NO", "DATA"):
    1648            return self._parse_withdata(no=True)
    1649
    1650        if not self._next:
    1651            return None
    1652
    1653        return self._parse_withisolatedloading()
    1654
    1655    # https://dev.mysql.com/doc/refman/8.0/en/create-view.html
    1656    def _parse_definer(self) -> t.Optional[exp.DefinerProperty]:
    1657        self._match(TokenType.EQ)
    1658
    1659        user = self._parse_id_var()
    1660        self._match(TokenType.PARAMETER)
    1661        host = self._parse_id_var() or (self._match(TokenType.MOD) and self._prev.text)
    1662
    1663        if not user or not host:
    1664            return None
    1665
    1666        return exp.DefinerProperty(this=f"{user}@{host}")
    1667
    1668    def _parse_withjournaltable(self) -> exp.WithJournalTableProperty:
    1669        self._match(TokenType.TABLE)
    1670        self._match(TokenType.EQ)
    1671        return self.expression(exp.WithJournalTableProperty, this=self._parse_table_parts())
    1672
    1673    def _parse_log(self, no: bool = False) -> exp.LogProperty:
    1674        return self.expression(exp.LogProperty, no=no)
    1675
    1676    def _parse_journal(self, **kwargs) -> exp.JournalProperty:
    1677        return self.expression(exp.JournalProperty, **kwargs)
    1678
    1679    def _parse_checksum(self) -> exp.ChecksumProperty:
    1680        self._match(TokenType.EQ)
    1681
    1682        on = None
    1683        if self._match(TokenType.ON):
    1684            on = True
    1685        elif self._match_text_seq("OFF"):
    1686            on = False
    1687
    1688        return self.expression(exp.ChecksumProperty, on=on, default=self._match(TokenType.DEFAULT))
    1689
    1690    def _parse_cluster(self, wrapped: bool = False) -> exp.Cluster:
    1691        return self.expression(
    1692            exp.Cluster,
    1693            expressions=(
    1694                self._parse_wrapped_csv(self._parse_ordered)
    1695                if wrapped
    1696                else self._parse_csv(self._parse_ordered)
    1697            ),
    1698        )
    1699
    1700    def _parse_clustered_by(self) -> exp.ClusteredByProperty:
    1701        self._match_text_seq("BY")
    1702
    1703        self._match_l_paren()
    1704        expressions = self._parse_csv(self._parse_column)
    1705        self._match_r_paren()
    1706
    1707        if self._match_text_seq("SORTED", "BY"):
    1708            self._match_l_paren()
    1709            sorted_by = self._parse_csv(self._parse_ordered)
    1710            self._match_r_paren()
    1711        else:
    1712            sorted_by = None
    1713
    1714        self._match(TokenType.INTO)
    1715        buckets = self._parse_number()
    1716        self._match_text_seq("BUCKETS")
    1717
    1718        return self.expression(
    1719            exp.ClusteredByProperty,
    1720            expressions=expressions,
    1721            sorted_by=sorted_by,
    1722            buckets=buckets,
    1723        )
    1724
    1725    def _parse_copy_property(self) -> t.Optional[exp.CopyGrantsProperty]:
    1726        if not self._match_text_seq("GRANTS"):
    1727            self._retreat(self._index - 1)
    1728            return None
    1729
    1730        return self.expression(exp.CopyGrantsProperty)
    1731
    1732    def _parse_freespace(self) -> exp.FreespaceProperty:
    1733        self._match(TokenType.EQ)
    1734        return self.expression(
    1735            exp.FreespaceProperty, this=self._parse_number(), percent=self._match(TokenType.PERCENT)
    1736        )
    1737
    1738    def _parse_mergeblockratio(
    1739        self, no: bool = False, default: bool = False
    1740    ) -> exp.MergeBlockRatioProperty:
    1741        if self._match(TokenType.EQ):
    1742            return self.expression(
    1743                exp.MergeBlockRatioProperty,
    1744                this=self._parse_number(),
    1745                percent=self._match(TokenType.PERCENT),
    1746            )
    1747
    1748        return self.expression(exp.MergeBlockRatioProperty, no=no, default=default)
    1749
    1750    def _parse_datablocksize(
    1751        self,
    1752        default: t.Optional[bool] = None,
    1753        minimum: t.Optional[bool] = None,
    1754        maximum: t.Optional[bool] = None,
    1755    ) -> exp.DataBlocksizeProperty:
    1756        self._match(TokenType.EQ)
    1757        size = self._parse_number()
    1758
    1759        units = None
    1760        if self._match_texts(("BYTES", "KBYTES", "KILOBYTES")):
    1761            units = self._prev.text
    1762
    1763        return self.expression(
    1764            exp.DataBlocksizeProperty,
    1765            size=size,
    1766            units=units,
    1767            default=default,
    1768            minimum=minimum,
    1769            maximum=maximum,
    1770        )
    1771
    1772    def _parse_blockcompression(self) -> exp.BlockCompressionProperty:
    1773        self._match(TokenType.EQ)
    1774        always = self._match_text_seq("ALWAYS")
    1775        manual = self._match_text_seq("MANUAL")
    1776        never = self._match_text_seq("NEVER")
    1777        default = self._match_text_seq("DEFAULT")
    1778
    1779        autotemp = None
    1780        if self._match_text_seq("AUTOTEMP"):
    1781            autotemp = self._parse_schema()
    1782
    1783        return self.expression(
    1784            exp.BlockCompressionProperty,
    1785            always=always,
    1786            manual=manual,
    1787            never=never,
    1788            default=default,
    1789            autotemp=autotemp,
    1790        )
    1791
    1792    def _parse_withisolatedloading(self) -> exp.IsolatedLoadingProperty:
    1793        no = self._match_text_seq("NO")
    1794        concurrent = self._match_text_seq("CONCURRENT")
    1795        self._match_text_seq("ISOLATED", "LOADING")
    1796        for_all = self._match_text_seq("FOR", "ALL")
    1797        for_insert = self._match_text_seq("FOR", "INSERT")
    1798        for_none = self._match_text_seq("FOR", "NONE")
    1799        return self.expression(
    1800            exp.IsolatedLoadingProperty,
    1801            no=no,
    1802            concurrent=concurrent,
    1803            for_all=for_all,
    1804            for_insert=for_insert,
    1805            for_none=for_none,
    1806        )
    1807
    1808    def _parse_locking(self) -> exp.LockingProperty:
    1809        if self._match(TokenType.TABLE):
    1810            kind = "TABLE"
    1811        elif self._match(TokenType.VIEW):
    1812            kind = "VIEW"
    1813        elif self._match(TokenType.ROW):
    1814            kind = "ROW"
    1815        elif self._match_text_seq("DATABASE"):
    1816            kind = "DATABASE"
    1817        else:
    1818            kind = None
    1819
    1820        if kind in ("DATABASE", "TABLE", "VIEW"):
    1821            this = self._parse_table_parts()
    1822        else:
    1823            this = None
    1824
    1825        if self._match(TokenType.FOR):
    1826            for_or_in = "FOR"
    1827        elif self._match(TokenType.IN):
    1828            for_or_in = "IN"
    1829        else:
    1830            for_or_in = None
    1831
    1832        if self._match_text_seq("ACCESS"):
    1833            lock_type = "ACCESS"
    1834        elif self._match_texts(("EXCL", "EXCLUSIVE")):
    1835            lock_type = "EXCLUSIVE"
    1836        elif self._match_text_seq("SHARE"):
    1837            lock_type = "SHARE"
    1838        elif self._match_text_seq("READ"):
    1839            lock_type = "READ"
    1840        elif self._match_text_seq("WRITE"):
    1841            lock_type = "WRITE"
    1842        elif self._match_text_seq("CHECKSUM"):
    1843            lock_type = "CHECKSUM"
    1844        else:
    1845            lock_type = None
    1846
    1847        override = self._match_text_seq("OVERRIDE")
    1848
    1849        return self.expression(
    1850            exp.LockingProperty,
    1851            this=this,
    1852            kind=kind,
    1853            for_or_in=for_or_in,
    1854            lock_type=lock_type,
    1855            override=override,
    1856        )
    1857
    1858    def _parse_partition_by(self) -> t.List[exp.Expression]:
    1859        if self._match(TokenType.PARTITION_BY):
    1860            return self._parse_csv(self._parse_conjunction)
    1861        return []
    1862
    1863    def _parse_partition_bound_spec(self) -> exp.PartitionBoundSpec:
    1864        def _parse_partition_bound_expr() -> t.Optional[exp.Expression]:
    1865            if self._match_text_seq("MINVALUE"):
    1866                return exp.var("MINVALUE")
    1867            if self._match_text_seq("MAXVALUE"):
    1868                return exp.var("MAXVALUE")
    1869            return self._parse_bitwise()
    1870
    1871        this: t.Optional[exp.Expression | t.List[exp.Expression]] = None
    1872        expression = None
    1873        from_expressions = None
    1874        to_expressions = None
    1875
    1876        if self._match(TokenType.IN):
    1877            this = self._parse_wrapped_csv(self._parse_bitwise)
    1878        elif self._match(TokenType.FROM):
    1879            from_expressions = self._parse_wrapped_csv(_parse_partition_bound_expr)
    1880            self._match_text_seq("TO")
    1881            to_expressions = self._parse_wrapped_csv(_parse_partition_bound_expr)
    1882        elif self._match_text_seq("WITH", "(", "MODULUS"):
    1883            this = self._parse_number()
    1884            self._match_text_seq(",", "REMAINDER")
    1885            expression = self._parse_number()
    1886            self._match_r_paren()
    1887        else:
    1888            self.raise_error("Failed to parse partition bound spec.")
    1889
    1890        return self.expression(
    1891            exp.PartitionBoundSpec,
    1892            this=this,
    1893            expression=expression,
    1894            from_expressions=from_expressions,
    1895            to_expressions=to_expressions,
    1896        )
    1897
    1898    # https://www.postgresql.org/docs/current/sql-createtable.html
    1899    def _parse_partitioned_of(self) -> t.Optional[exp.PartitionedOfProperty]:
    1900        if not self._match_text_seq("OF"):
    1901            self._retreat(self._index - 1)
    1902            return None
    1903
    1904        this = self._parse_table(schema=True)
    1905
    1906        if self._match(TokenType.DEFAULT):
    1907            expression: exp.Var | exp.PartitionBoundSpec = exp.var("DEFAULT")
    1908        elif self._match_text_seq("FOR", "VALUES"):
    1909            expression = self._parse_partition_bound_spec()
    1910        else:
    1911            self.raise_error("Expecting either DEFAULT or FOR VALUES clause.")
    1912
    1913        return self.expression(exp.PartitionedOfProperty, this=this, expression=expression)
    1914
    1915    def _parse_partitioned_by(self) -> exp.PartitionedByProperty:
    1916        self._match(TokenType.EQ)
    1917        return self.expression(
    1918            exp.PartitionedByProperty,
    1919            this=self._parse_schema() or self._parse_bracket(self._parse_field()),
    1920        )
    1921
    1922    def _parse_withdata(self, no: bool = False) -> exp.WithDataProperty:
    1923        if self._match_text_seq("AND", "STATISTICS"):
    1924            statistics = True
    1925        elif self._match_text_seq("AND", "NO", "STATISTICS"):
    1926            statistics = False
    1927        else:
    1928            statistics = None
    1929
    1930        return self.expression(exp.WithDataProperty, no=no, statistics=statistics)
    1931
    1932    def _parse_contains_property(self) -> t.Optional[exp.SqlReadWriteProperty]:
    1933        if self._match_text_seq("SQL"):
    1934            return self.expression(exp.SqlReadWriteProperty, this="CONTAINS SQL")
    1935        return None
    1936
    1937    def _parse_modifies_property(self) -> t.Optional[exp.SqlReadWriteProperty]:
    1938        if self._match_text_seq("SQL", "DATA"):
    1939            return self.expression(exp.SqlReadWriteProperty, this="MODIFIES SQL DATA")
    1940        return None
    1941
    1942    def _parse_no_property(self) -> t.Optional[exp.Expression]:
    1943        if self._match_text_seq("PRIMARY", "INDEX"):
    1944            return exp.NoPrimaryIndexProperty()
    1945        if self._match_text_seq("SQL"):
    1946            return self.expression(exp.SqlReadWriteProperty, this="NO SQL")
    1947        return None
    1948
    1949    def _parse_on_property(self) -> t.Optional[exp.Expression]:
    1950        if self._match_text_seq("COMMIT", "PRESERVE", "ROWS"):
    1951            return exp.OnCommitProperty()
    1952        if self._match_text_seq("COMMIT", "DELETE", "ROWS"):
    1953            return exp.OnCommitProperty(delete=True)
    1954        return self.expression(exp.OnProperty, this=self._parse_schema(self._parse_id_var()))
    1955
    1956    def _parse_reads_property(self) -> t.Optional[exp.SqlReadWriteProperty]:
    1957        if self._match_text_seq("SQL", "DATA"):
    1958            return self.expression(exp.SqlReadWriteProperty, this="READS SQL DATA")
    1959        return None
    1960
    1961    def _parse_distkey(self) -> exp.DistKeyProperty:
    1962        return self.expression(exp.DistKeyProperty, this=self._parse_wrapped(self._parse_id_var))
    1963
    1964    def _parse_create_like(self) -> t.Optional[exp.LikeProperty]:
    1965        table = self._parse_table(schema=True)
    1966
    1967        options = []
    1968        while self._match_texts(("INCLUDING", "EXCLUDING")):
    1969            this = self._prev.text.upper()
    1970
    1971            id_var = self._parse_id_var()
    1972            if not id_var:
    1973                return None
    1974
    1975            options.append(
    1976                self.expression(exp.Property, this=this, value=exp.var(id_var.this.upper()))
    1977            )
    1978
    1979        return self.expression(exp.LikeProperty, this=table, expressions=options)
    1980
    1981    def _parse_sortkey(self, compound: bool = False) -> exp.SortKeyProperty:
    1982        return self.expression(
    1983            exp.SortKeyProperty, this=self._parse_wrapped_id_vars(), compound=compound
    1984        )
    1985
    1986    def _parse_character_set(self, default: bool = False) -> exp.CharacterSetProperty:
    1987        self._match(TokenType.EQ)
    1988        return self.expression(
    1989            exp.CharacterSetProperty, this=self._parse_var_or_string(), default=default
    1990        )
    1991
    1992    def _parse_remote_with_connection(self) -> exp.RemoteWithConnectionModelProperty:
    1993        self._match_text_seq("WITH", "CONNECTION")
    1994        return self.expression(
    1995            exp.RemoteWithConnectionModelProperty, this=self._parse_table_parts()
    1996        )
    1997
    1998    def _parse_returns(self) -> exp.ReturnsProperty:
    1999        value: t.Optional[exp.Expression]
    2000        is_table = self._match(TokenType.TABLE)
    2001
    2002        if is_table:
    2003            if self._match(TokenType.LT):
    2004                value = self.expression(
    2005                    exp.Schema,
    2006                    this="TABLE",
    2007                    expressions=self._parse_csv(self._parse_struct_types),
    2008                )
    2009                if not self._match(TokenType.GT):
    2010                    self.raise_error("Expecting >")
    2011            else:
    2012                value = self._parse_schema(exp.var("TABLE"))
    2013        else:
    2014            value = self._parse_types()
    2015
    2016        return self.expression(exp.ReturnsProperty, this=value, is_table=is_table)
    2017
    2018    def _parse_describe(self) -> exp.Describe:
    2019        kind = self._match_set(self.CREATABLES) and self._prev.text
    2020        extended = self._match_text_seq("EXTENDED")
    2021        this = self._parse_table(schema=True)
    2022        properties = self._parse_properties()
    2023        expressions = properties.expressions if properties else None
    2024        return self.expression(
    2025            exp.Describe, this=this, extended=extended, kind=kind, expressions=expressions
    2026        )
    2027
    2028    def _parse_insert(self) -> exp.Insert:
    2029        comments = ensure_list(self._prev_comments)
    2030        overwrite = self._match(TokenType.OVERWRITE)
    2031        ignore = self._match(TokenType.IGNORE)
    2032        local = self._match_text_seq("LOCAL")
    2033        alternative = None
    2034
    2035        if self._match_text_seq("DIRECTORY"):
    2036            this: t.Optional[exp.Expression] = self.expression(
    2037                exp.Directory,
    2038                this=self._parse_var_or_string(),
    2039                local=local,
    2040                row_format=self._parse_row_format(match_row=True),
    2041            )
    2042        else:
    2043            if self._match(TokenType.OR):
    2044                alternative = self._match_texts(self.INSERT_ALTERNATIVES) and self._prev.text
    2045
    2046            self._match(TokenType.INTO)
    2047            comments += ensure_list(self._prev_comments)
    2048            self._match(TokenType.TABLE)
    2049            this = self._parse_table(schema=True)
    2050
    2051        returning = self._parse_returning()
    2052
    2053        return self.expression(
    2054            exp.Insert,
    2055            comments=comments,
    2056            this=this,
    2057            by_name=self._match_text_seq("BY", "NAME"),
    2058            exists=self._parse_exists(),
    2059            partition=self._parse_partition(),
    2060            where=self._match_pair(TokenType.REPLACE, TokenType.WHERE)
    2061            and self._parse_conjunction(),
    2062            expression=self._parse_ddl_select(),
    2063            conflict=self._parse_on_conflict(),
    2064            returning=returning or self._parse_returning(),
    2065            overwrite=overwrite,
    2066            alternative=alternative,
    2067            ignore=ignore,
    2068        )
    2069
    2070    def _parse_kill(self) -> exp.Kill:
    2071        kind = exp.var(self._prev.text) if self._match_texts(("CONNECTION", "QUERY")) else None
    2072
    2073        return self.expression(
    2074            exp.Kill,
    2075            this=self._parse_primary(),
    2076            kind=kind,
    2077        )
    2078
    2079    def _parse_on_conflict(self) -> t.Optional[exp.OnConflict]:
    2080        conflict = self._match_text_seq("ON", "CONFLICT")
    2081        duplicate = self._match_text_seq("ON", "DUPLICATE", "KEY")
    2082
    2083        if not conflict and not duplicate:
    2084            return None
    2085
    2086        nothing = None
    2087        expressions = None
    2088        key = None
    2089        constraint = None
    2090
    2091        if conflict:
    2092            if self._match_text_seq("ON", "CONSTRAINT"):
    2093                constraint = self._parse_id_var()
    2094            else:
    2095                key = self._parse_csv(self._parse_value)
    2096
    2097        self._match_text_seq("DO")
    2098        if self._match_text_seq("NOTHING"):
    2099            nothing = True
    2100        else:
    2101            self._match(TokenType.UPDATE)
    2102            self._match(TokenType.SET)
    2103            expressions = self._parse_csv(self._parse_equality)
    2104
    2105        return self.expression(
    2106            exp.OnConflict,
    2107            duplicate=duplicate,
    2108            expressions=expressions,
    2109            nothing=nothing,
    2110            key=key,
    2111            constraint=constraint,
    2112        )
    2113
    2114    def _parse_returning(self) -> t.Optional[exp.Returning]:
    2115        if not self._match(TokenType.RETURNING):
    2116            return None
    2117        return self.expression(
    2118            exp.Returning,
    2119            expressions=self._parse_csv(self._parse_expression),
    2120            into=self._match(TokenType.INTO) and self._parse_table_part(),
    2121        )
    2122
    2123    def _parse_row(self) -> t.Optional[exp.RowFormatSerdeProperty | exp.RowFormatDelimitedProperty]:
    2124        if not self._match(TokenType.FORMAT):
    2125            return None
    2126        return self._parse_row_format()
    2127
    2128    def _parse_row_format(
    2129        self, match_row: bool = False
    2130    ) -> t.Optional[exp.RowFormatSerdeProperty | exp.RowFormatDelimitedProperty]:
    2131        if match_row and not self._match_pair(TokenType.ROW, TokenType.FORMAT):
    2132            return None
    2133
    2134        if self._match_text_seq("SERDE"):
    2135            this = self._parse_string()
    2136
    2137            serde_properties = None
    2138            if self._match(TokenType.SERDE_PROPERTIES):
    2139                serde_properties = self.expression(
    2140                    exp.SerdeProperties, expressions=self._parse_wrapped_csv(self._parse_property)
    2141                )
    2142
    2143            return self.expression(
    2144                exp.RowFormatSerdeProperty, this=this, serde_properties=serde_properties
    2145            )
    2146
    2147        self._match_text_seq("DELIMITED")
    2148
    2149        kwargs = {}
    2150
    2151        if self._match_text_seq("FIELDS", "TERMINATED", "BY"):
    2152            kwargs["fields"] = self._parse_string()
    2153            if self._match_text_seq("ESCAPED", "BY"):
    2154                kwargs["escaped"] = self._parse_string()
    2155        if self._match_text_seq("COLLECTION", "ITEMS", "TERMINATED", "BY"):
    2156            kwargs["collection_items"] = self._parse_string()
    2157        if self._match_text_seq("MAP", "KEYS", "TERMINATED", "BY"):
    2158            kwargs["map_keys"] = self._parse_string()
    2159        if self._match_text_seq("LINES", "TERMINATED", "BY"):
    2160            kwargs["lines"] = self._parse_string()
    2161        if self._match_text_seq("NULL", "DEFINED", "AS"):
    2162            kwargs["null"] = self._parse_string()
    2163
    2164        return self.expression(exp.RowFormatDelimitedProperty, **kwargs)  # type: ignore
    2165
    2166    def _parse_load(self) -> exp.LoadData | exp.Command:
    2167        if self._match_text_seq("DATA"):
    2168            local = self._match_text_seq("LOCAL")
    2169            self._match_text_seq("INPATH")
    2170            inpath = self._parse_string()
    2171            overwrite = self._match(TokenType.OVERWRITE)
    2172            self._match_pair(TokenType.INTO, TokenType.TABLE)
    2173
    2174            return self.expression(
    2175                exp.LoadData,
    2176                this=self._parse_table(schema=True),
    2177                local=local,
    2178                overwrite=overwrite,
    2179                inpath=inpath,
    2180                partition=self._parse_partition(),
    2181                input_format=self._match_text_seq("INPUTFORMAT") and self._parse_string(),
    2182                serde=self._match_text_seq("SERDE") and self._parse_string(),
    2183            )
    2184        return self._parse_as_command(self._prev)
    2185
    2186    def _parse_delete(self) -> exp.Delete:
    2187        # This handles MySQL's "Multiple-Table Syntax"
    2188        # https://dev.mysql.com/doc/refman/8.0/en/delete.html
    2189        tables = None
    2190        comments = self._prev_comments
    2191        if not self._match(TokenType.FROM, advance=False):
    2192            tables = self._parse_csv(self._parse_table) or None
    2193
    2194        returning = self._parse_returning()
    2195
    2196        return self.expression(
    2197            exp.Delete,
    2198            comments=comments,
    2199            tables=tables,
    2200            this=self._match(TokenType.FROM) and self._parse_table(joins=True),
    2201            using=self._match(TokenType.USING) and self._parse_table(joins=True),
    2202            where=self._parse_where(),
    2203            returning=returning or self._parse_returning(),
    2204            limit=self._parse_limit(),
    2205        )
    2206
    2207    def _parse_update(self) -> exp.Update:
    2208        comments = self._prev_comments
    2209        this = self._parse_table(joins=True, alias_tokens=self.UPDATE_ALIAS_TOKENS)
    2210        expressions = self._match(TokenType.SET) and self._parse_csv(self._parse_equality)
    2211        returning = self._parse_returning()
    2212        return self.expression(
    2213            exp.Update,
    2214            comments=comments,
    2215            **{  # type: ignore
    2216                "this": this,
    2217                "expressions": expressions,
    2218                "from": self._parse_from(joins=True),
    2219                "where": self._parse_where(),
    2220                "returning": returning or self._parse_returning(),
    2221                "order": self._parse_order(),
    2222                "limit": self._parse_limit(),
    2223            },
    2224        )
    2225
    2226    def _parse_uncache(self) -> exp.Uncache:
    2227        if not self._match(TokenType.TABLE):
    2228            self.raise_error("Expecting TABLE after UNCACHE")
    2229
    2230        return self.expression(
    2231            exp.Uncache, exists=self._parse_exists(), this=self._parse_table(schema=True)
    2232        )
    2233
    2234    def _parse_cache(self) -> exp.Cache:
    2235        lazy = self._match_text_seq("LAZY")
    2236        self._match(TokenType.TABLE)
    2237        table = self._parse_table(schema=True)
    2238
    2239        options = []
    2240        if self._match_text_seq("OPTIONS"):
    2241            self._match_l_paren()
    2242            k = self._parse_string()
    2243            self._match(TokenType.EQ)
    2244            v = self._parse_string()
    2245            options = [k, v]
    2246            self._match_r_paren()
    2247
    2248        self._match(TokenType.ALIAS)
    2249        return self.expression(
    2250            exp.Cache,
    2251            this=table,
    2252            lazy=lazy,
    2253            options=options,
    2254            expression=self._parse_select(nested=True),
    2255        )
    2256
    2257    def _parse_partition(self) -> t.Optional[exp.Partition]:
    2258        if not self._match(TokenType.PARTITION):
    2259            return None
    2260
    2261        return self.expression(
    2262            exp.Partition, expressions=self._parse_wrapped_csv(self._parse_conjunction)
    2263        )
    2264
    2265    def _parse_value(self) -> exp.Tuple:
    2266        if self._match(TokenType.L_PAREN):
    2267            expressions = self._parse_csv(self._parse_expression)
    2268            self._match_r_paren()
    2269            return self.expression(exp.Tuple, expressions=expressions)
    2270
    2271        # In presto we can have VALUES 1, 2 which results in 1 column & 2 rows.
    2272        # https://prestodb.io/docs/current/sql/values.html
    2273        return self.expression(exp.Tuple, expressions=[self._parse_expression()])
    2274
    2275    def _parse_projections(self) -> t.List[exp.Expression]:
    2276        return self._parse_expressions()
    2277
    2278    def _parse_select(
    2279        self,
    2280        nested: bool = False,
    2281        table: bool = False,
    2282        parse_subquery_alias: bool = True,
    2283        parse_set_operation: bool = True,
    2284    ) -> t.Optional[exp.Expression]:
    2285        cte = self._parse_with()
    2286
    2287        if cte:
    2288            this = self._parse_statement()
    2289
    2290            if not this:
    2291                self.raise_error("Failed to parse any statement following CTE")
    2292                return cte
    2293
    2294            if "with" in this.arg_types:
    2295                this.set("with", cte)
    2296            else:
    2297                self.raise_error(f"{this.key} does not support CTE")
    2298                this = cte
    2299
    2300            return this
    2301
    2302        # duckdb supports leading with FROM x
    2303        from_ = self._parse_from() if self._match(TokenType.FROM, advance=False) else None
    2304
    2305        if self._match(TokenType.SELECT):
    2306            comments = self._prev_comments
    2307
    2308            hint = self._parse_hint()
    2309            all_ = self._match(TokenType.ALL)
    2310            distinct = self._match_set(self.DISTINCT_TOKENS)
    2311
    2312            kind = (
    2313                self._match(TokenType.ALIAS)
    2314                and self._match_texts(("STRUCT", "VALUE"))
    2315                and self._prev.text.upper()
    2316            )
    2317
    2318            if distinct:
    2319                distinct = self.expression(
    2320                    exp.Distinct,
    2321                    on=self._parse_value() if self._match(TokenType.ON) else None,
    2322                )
    2323
    2324            if all_ and distinct:
    2325                self.raise_error("Cannot specify both ALL and DISTINCT after SELECT")
    2326
    2327            limit = self._parse_limit(top=True)
    2328            projections = self._parse_projections()
    2329
    2330            this = self.expression(
    2331                exp.Select,
    2332                kind=kind,
    2333                hint=hint,
    2334                distinct=distinct,
    2335                expressions=projections,
    2336                limit=limit,
    2337            )
    2338            this.comments = comments
    2339
    2340            into = self._parse_into()
    2341            if into:
    2342                this.set("into", into)
    2343
    2344            if not from_:
    2345                from_ = self._parse_from()
    2346
    2347            if from_:
    2348                this.set("from", from_)
    2349
    2350            this = self._parse_query_modifiers(this)
    2351        elif (table or nested) and self._match(TokenType.L_PAREN):
    2352            if self._match(TokenType.PIVOT):
    2353                this = self._parse_simplified_pivot()
    2354            elif self._match(TokenType.FROM):
    2355                this = exp.select("*").from_(
    2356                    t.cast(exp.From, self._parse_from(skip_from_token=True))
    2357                )
    2358            else:
    2359                this = (
    2360                    self._parse_table()
    2361                    if table
    2362                    else self._parse_select(nested=True, parse_set_operation=False)
    2363                )
    2364                this = self._parse_query_modifiers(self._parse_set_operations(this))
    2365
    2366            self._match_r_paren()
    2367
    2368            # We return early here so that the UNION isn't attached to the subquery by the
    2369            # following call to _parse_set_operations, but instead becomes the parent node
    2370            return self._parse_subquery(this, parse_alias=parse_subquery_alias)
    2371        elif self._match(TokenType.VALUES):
    2372            this = self.expression(
    2373                exp.Values,
    2374                expressions=self._parse_csv(self._parse_value),
    2375                alias=self._parse_table_alias(),
    2376            )
    2377        elif from_:
    2378            this = exp.select("*").from_(from_.this, copy=False)
    2379        else:
    2380            this = None
    2381
    2382        if parse_set_operation:
    2383            return self._parse_set_operations(this)
    2384        return this
    2385
    2386    def _parse_with(self, skip_with_token: bool = False) -> t.Optional[exp.With]:
    2387        if not skip_with_token and not self._match(TokenType.WITH):
    2388            return None
    2389
    2390        comments = self._prev_comments
    2391        recursive = self._match(TokenType.RECURSIVE)
    2392
    2393        expressions = []
    2394        while True:
    2395            expressions.append(self._parse_cte())
    2396
    2397            if not self._match(TokenType.COMMA) and not self._match(TokenType.WITH):
    2398                break
    2399            else:
    2400                self._match(TokenType.WITH)
    2401
    2402        return self.expression(
    2403            exp.With, comments=comments, expressions=expressions, recursive=recursive
    2404        )
    2405
    2406    def _parse_cte(self) -> exp.CTE:
    2407        alias = self._parse_table_alias(self.ID_VAR_TOKENS)
    2408        if not alias or not alias.this:
    2409            self.raise_error("Expected CTE to have alias")
    2410
    2411        self._match(TokenType.ALIAS)
    2412        return self.expression(
    2413            exp.CTE, this=self._parse_wrapped(self._parse_statement), alias=alias
    2414        )
    2415
    2416    def _parse_table_alias(
    2417        self, alias_tokens: t.Optional[t.Collection[TokenType]] = None
    2418    ) -> t.Optional[exp.TableAlias]:
    2419        any_token = self._match(TokenType.ALIAS)
    2420        alias = (
    2421            self._parse_id_var(any_token=any_token, tokens=alias_tokens or self.TABLE_ALIAS_TOKENS)
    2422            or self._parse_string_as_identifier()
    2423        )
    2424
    2425        index = self._index
    2426        if self._match(TokenType.L_PAREN):
    2427            columns = self._parse_csv(self._parse_function_parameter)
    2428            self._match_r_paren() if columns else self._retreat(index)
    2429        else:
    2430            columns = None
    2431
    2432        if not alias and not columns:
    2433            return None
    2434
    2435        return self.expression(exp.TableAlias, this=alias, columns=columns)
    2436
    2437    def _parse_subquery(
    2438        self, this: t.Optional[exp.Expression], parse_alias: bool = True
    2439    ) -> t.Optional[exp.Subquery]:
    2440        if not this:
    2441            return None
    2442
    2443        return self.expression(
    2444            exp.Subquery,
    2445            this=this,
    2446            pivots=self._parse_pivots(),
    2447            alias=self._parse_table_alias() if parse_alias else None,
    2448        )
    2449
    2450    def _parse_query_modifiers(
    2451        self, this: t.Optional[exp.Expression]
    2452    ) -> t.Optional[exp.Expression]:
    2453        if isinstance(this, self.MODIFIABLES):
    2454            for join in iter(self._parse_join, None):
    2455                this.append("joins", join)
    2456            for lateral in iter(self._parse_lateral, None):
    2457                this.append("laterals", lateral)
    2458
    2459            while True:
    2460                if self._match_set(self.QUERY_MODIFIER_PARSERS, advance=False):
    2461                    parser = self.QUERY_MODIFIER_PARSERS[self._curr.token_type]
    2462                    key, expression = parser(self)
    2463
    2464                    if expression:
    2465                        this.set(key, expression)
    2466                        if key == "limit":
    2467                            offset = expression.args.pop("offset", None)
    2468                            if offset:
    2469                                this.set("offset", exp.Offset(expression=offset))
    2470                        continue
    2471                break
    2472        return this
    2473
    2474    def _parse_hint(self) -> t.Optional[exp.Hint]:
    2475        if self._match(TokenType.HINT):
    2476            hints = []
    2477            for hint in iter(lambda: self._parse_csv(self._parse_function), []):
    2478                hints.extend(hint)
    2479
    2480            if not self._match_pair(TokenType.STAR, TokenType.SLASH):
    2481                self.raise_error("Expected */ after HINT")
    2482
    2483            return self.expression(exp.Hint, expressions=hints)
    2484
    2485        return None
    2486
    2487    def _parse_into(self) -> t.Optional[exp.Into]:
    2488        if not self._match(TokenType.INTO):
    2489            return None
    2490
    2491        temp = self._match(TokenType.TEMPORARY)
    2492        unlogged = self._match_text_seq("UNLOGGED")
    2493        self._match(TokenType.TABLE)
    2494
    2495        return self.expression(
    2496            exp.Into, this=self._parse_table(schema=True), temporary=temp, unlogged=unlogged
    2497        )
    2498
    2499    def _parse_from(
    2500        self, joins: bool = False, skip_from_token: bool = False
    2501    ) -> t.Optional[exp.From]:
    2502        if not skip_from_token and not self._match(TokenType.FROM):
    2503            return None
    2504
    2505        return self.expression(
    2506            exp.From, comments=self._prev_comments, this=self._parse_table(joins=joins)
    2507        )
    2508
    2509    def _parse_match_recognize(self) -> t.Optional[exp.MatchRecognize]:
    2510        if not self._match(TokenType.MATCH_RECOGNIZE):
    2511            return None
    2512
    2513        self._match_l_paren()
    2514
    2515        partition = self._parse_partition_by()
    2516        order = self._parse_order()
    2517        measures = self._parse_expressions() if self._match_text_seq("MEASURES") else None
    2518
    2519        if self._match_text_seq("ONE", "ROW", "PER", "MATCH"):
    2520            rows = exp.var("ONE ROW PER MATCH")
    2521        elif self._match_text_seq("ALL", "ROWS", "PER", "MATCH"):
    2522            text = "ALL ROWS PER MATCH"
    2523            if self._match_text_seq("SHOW", "EMPTY", "MATCHES"):
    2524                text += " SHOW EMPTY MATCHES"
    2525            elif self._match_text_seq("OMIT", "EMPTY", "MATCHES"):
    2526                text += " OMIT EMPTY MATCHES"
    2527            elif self._match_text_seq("WITH", "UNMATCHED", "ROWS"):
    2528                text += " WITH UNMATCHED ROWS"
    2529            rows = exp.var(text)
    2530        else:
    2531            rows = None
    2532
    2533        if self._match_text_seq("AFTER", "MATCH", "SKIP"):
    2534            text = "AFTER MATCH SKIP"
    2535            if self._match_text_seq("PAST", "LAST", "ROW"):
    2536                text += " PAST LAST ROW"
    2537            elif self._match_text_seq("TO", "NEXT", "ROW"):
    2538                text += " TO NEXT ROW"
    2539            elif self._match_text_seq("TO", "FIRST"):
    2540                text += f" TO FIRST {self._advance_any().text}"  # type: ignore
    2541            elif self._match_text_seq("TO", "LAST"):
    2542                text += f" TO LAST {self._advance_any().text}"  # type: ignore
    2543            after = exp.var(text)
    2544        else:
    2545            after = None
    2546
    2547        if self._match_text_seq("PATTERN"):
    2548            self._match_l_paren()
    2549
    2550            if not self._curr:
    2551                self.raise_error("Expecting )", self._curr)
    2552
    2553            paren = 1
    2554            start = self._curr
    2555
    2556            while self._curr and paren > 0:
    2557                if self._curr.token_type == TokenType.L_PAREN:
    2558                    paren += 1
    2559                if self._curr.token_type == TokenType.R_PAREN:
    2560                    paren -= 1
    2561
    2562                end = self._prev
    2563                self._advance()
    2564
    2565            if paren > 0:
    2566                self.raise_error("Expecting )", self._curr)
    2567
    2568            pattern = exp.var(self._find_sql(start, end))
    2569        else:
    2570            pattern = None
    2571
    2572        define = (
    2573            self._parse_csv(self._parse_name_as_expression)
    2574            if self._match_text_seq("DEFINE")
    2575            else None
    2576        )
    2577
    2578        self._match_r_paren()
    2579
    2580        return self.expression(
    2581            exp.MatchRecognize,
    2582            partition_by=partition,
    2583            order=order,
    2584            measures=measures,
    2585            rows=rows,
    2586            after=after,
    2587            pattern=pattern,
    2588            define=define,
    2589            alias=self._parse_table_alias(),
    2590        )
    2591
    2592    def _parse_lateral(self) -> t.Optional[exp.Lateral]:
    2593        cross_apply = self._match_pair(TokenType.CROSS, TokenType.APPLY)
    2594        if not cross_apply and self._match_pair(TokenType.OUTER, TokenType.APPLY):
    2595            cross_apply = False
    2596
    2597        if cross_apply is not None:
    2598            this = self._parse_select(table=True)
    2599            view = None
    2600            outer = None
    2601        elif self._match(TokenType.LATERAL):
    2602            this = self._parse_select(table=True)
    2603            view = self._match(TokenType.VIEW)
    2604            outer = self._match(TokenType.OUTER)
    2605        else:
    2606            return None
    2607
    2608        if not this:
    2609            this = (
    2610                self._parse_unnest()
    2611                or self._parse_function()
    2612                or self._parse_id_var(any_token=False)
    2613            )
    2614
    2615            while self._match(TokenType.DOT):
    2616                this = exp.Dot(
    2617                    this=this,
    2618                    expression=self._parse_function() or self._parse_id_var(any_token=False),
    2619                )
    2620
    2621        if view:
    2622            table = self._parse_id_var(any_token=False)
    2623            columns = self._parse_csv(self._parse_id_var) if self._match(TokenType.ALIAS) else []
    2624            table_alias: t.Optional[exp.TableAlias] = self.expression(
    2625                exp.TableAlias, this=table, columns=columns
    2626            )
    2627        elif isinstance(this, (exp.Subquery, exp.Unnest)) and this.alias:
    2628            # We move the alias from the lateral's child node to the lateral itself
    2629            table_alias = this.args["alias"].pop()
    2630        else:
    2631            table_alias = self._parse_table_alias()
    2632
    2633        return self.expression(
    2634            exp.Lateral,
    2635            this=this,
    2636            view=view,
    2637            outer=outer,
    2638            alias=table_alias,
    2639            cross_apply=cross_apply,
    2640        )
    2641
    2642    def _parse_join_parts(
    2643        self,
    2644    ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
    2645        return (
    2646            self._match_set(self.JOIN_METHODS) and self._prev,
    2647            self._match_set(self.JOIN_SIDES) and self._prev,
    2648            self._match_set(self.JOIN_KINDS) and self._prev,
    2649        )
    2650
    2651    def _parse_join(
    2652        self, skip_join_token: bool = False, parse_bracket: bool = False
    2653    ) -> t.Optional[exp.Join]:
    2654        if self._match(TokenType.COMMA):
    2655            return self.expression(exp.Join, this=self._parse_table())
    2656
    2657        index = self._index
    2658        method, side, kind = self._parse_join_parts()
    2659        hint = self._prev.text if self._match_texts(self.JOIN_HINTS) else None
    2660        join = self._match(TokenType.JOIN)
    2661
    2662        if not skip_join_token and not join:
    2663            self._retreat(index)
    2664            kind = None
    2665            method = None
    2666            side = None
    2667
    2668        outer_apply = self._match_pair(TokenType.OUTER, TokenType.APPLY, False)
    2669        cross_apply = self._match_pair(TokenType.CROSS, TokenType.APPLY, False)
    2670
    2671        if not skip_join_token and not join and not outer_apply and not cross_apply:
    2672            return None
    2673
    2674        kwargs: t.Dict[str, t.Any] = {"this": self._parse_table(parse_bracket=parse_bracket)}
    2675
    2676        if method:
    2677            kwargs["method"] = method.text
    2678        if side:
    2679            kwargs["side"] = side.text
    2680        if kind:
    2681            kwargs["kind"] = kind.text
    2682        if hint:
    2683            kwargs["hint"] = hint
    2684
    2685        if self._match(TokenType.ON):
    2686            kwargs["on"] = self._parse_conjunction()
    2687        elif self._match(TokenType.USING):
    2688            kwargs["using"] = self._parse_wrapped_id_vars()
    2689        elif not (kind and kind.token_type == TokenType.CROSS):
    2690            index = self._index
    2691            join = self._parse_join()
    2692
    2693            if join and self._match(TokenType.ON):
    2694                kwargs["on"] = self._parse_conjunction()
    2695            elif join and self._match(TokenType.USING):
    2696                kwargs["using"] = self._parse_wrapped_id_vars()
    2697            else:
    2698                join = None
    2699                self._retreat(index)
    2700
    2701            kwargs["this"].set("joins", [join] if join else None)
    2702
    2703        comments = [c for token in (method, side, kind) if token for c in token.comments]
    2704        return self.expression(exp.Join, comments=comments, **kwargs)
    2705
    2706    def _parse_opclass(self) -> t.Optional[exp.Expression]:
    2707        this = self._parse_conjunction()
    2708        if self._match_texts(self.OPCLASS_FOLLOW_KEYWORDS, advance=False):
    2709            return this
    2710
    2711        if not self._match_set(self.OPTYPE_FOLLOW_TOKENS, advance=False):
    2712            return self.expression(exp.Opclass, this=this, expression=self._parse_table_parts())
    2713
    2714        return this
    2715
    2716    def _parse_index(
    2717        self,
    2718        index: t.Optional[exp.Expression] = None,
    2719    ) -> t.Optional[exp.Index]:
    2720        if index:
    2721            unique = None
    2722            primary = None
    2723            amp = None
    2724
    2725            self._match(TokenType.ON)
    2726            self._match(TokenType.TABLE)  # hive
    2727            table = self._parse_table_parts(schema=True)
    2728        else:
    2729            unique = self._match(TokenType.UNIQUE)
    2730            primary = self._match_text_seq("PRIMARY")
    2731            amp = self._match_text_seq("AMP")
    2732
    2733            if not self._match(TokenType.INDEX):
    2734                return None
    2735
    2736            index = self._parse_id_var()
    2737            table = None
    2738
    2739        using = self._parse_var(any_token=True) if self._match(TokenType.USING) else None
    2740
    2741        if self._match(TokenType.L_PAREN, advance=False):
    2742            columns = self._parse_wrapped_csv(lambda: self._parse_ordered(self._parse_opclass))
    2743        else:
    2744            columns = None
    2745
    2746        include = self._parse_wrapped_id_vars() if self._match_text_seq("INCLUDE") else None
    2747
    2748        return self.expression(
    2749            exp.Index,
    2750            this=index,
    2751            table=table,
    2752            using=using,
    2753            columns=columns,
    2754            unique=unique,
    2755            primary=primary,
    2756            amp=amp,
    2757            include=include,
    2758            partition_by=self._parse_partition_by(),
    2759            where=self._parse_where(),
    2760        )
    2761
    2762    def _parse_table_hints(self) -> t.Optional[t.List[exp.Expression]]:
    2763        hints: t.List[exp.Expression] = []
    2764        if self._match_pair(TokenType.WITH, TokenType.L_PAREN):
    2765            # https://learn.microsoft.com/en-us/sql/t-sql/queries/hints-transact-sql-table?view=sql-server-ver16
    2766            hints.append(
    2767                self.expression(
    2768                    exp.WithTableHint,
    2769                    expressions=self._parse_csv(
    2770                        lambda: self._parse_function() or self._parse_var(any_token=True)
    2771                    ),
    2772                )
    2773            )
    2774            self._match_r_paren()
    2775        else:
    2776            # https://dev.mysql.com/doc/refman/8.0/en/index-hints.html
    2777            while self._match_set(self.TABLE_INDEX_HINT_TOKENS):
    2778                hint = exp.IndexTableHint(this=self._prev.text.upper())
    2779
    2780                self._match_texts(("INDEX", "KEY"))
    2781                if self._match(TokenType.FOR):
    2782                    hint.set("target", self._advance_any() and self._prev.text.upper())
    2783
    2784                hint.set("expressions", self._parse_wrapped_id_vars())
    2785                hints.append(hint)
    2786
    2787        return hints or None
    2788
    2789    def _parse_table_part(self, schema: bool = False) -> t.Optional[exp.Expression]:
    2790        return (
    2791            (not schema and self._parse_function(optional_parens=False))
    2792            or self._parse_id_var(any_token=False)
    2793            or self._parse_string_as_identifier()
    2794            or self._parse_placeholder()
    2795        )
    2796
    2797    def _parse_table_parts(self, schema: bool = False, is_db_reference: bool = False) -> exp.Table:
    2798        catalog = None
    2799        db = None
    2800        table: t.Optional[exp.Expression | str] = self._parse_table_part(schema=schema)
    2801
    2802        while self._match(TokenType.DOT):
    2803            if catalog:
    2804                # This allows nesting the table in arbitrarily many dot expressions if needed
    2805                table = self.expression(
    2806                    exp.Dot, this=table, expression=self._parse_table_part(schema=schema)
    2807                )
    2808            else:
    2809                catalog = db
    2810                db = table
    2811                table = self._parse_table_part(schema=schema) or ""
    2812
    2813        if is_db_reference:
    2814            catalog = db
    2815            db = table
    2816            table = None
    2817
    2818        if not table and not is_db_reference:
    2819            self.raise_error(f"Expected table name but got {self._curr}")
    2820        if not db and is_db_reference:
    2821            self.raise_error(f"Expected database name but got {self._curr}")
    2822
    2823        return self.expression(
    2824            exp.Table, this=table, db=db, catalog=catalog, pivots=self._parse_pivots()
    2825        )
    2826
    2827    def _parse_table(
    2828        self,
    2829        schema: bool = False,
    2830        joins: bool = False,
    2831        alias_tokens: t.Optional[t.Collection[TokenType]] = None,
    2832        parse_bracket: bool = False,
    2833        is_db_reference: bool = False,
    2834    ) -> t.Optional[exp.Expression]:
    2835        lateral = self._parse_lateral()
    2836        if lateral:
    2837            return lateral
    2838
    2839        unnest = self._parse_unnest()
    2840        if unnest:
    2841            return unnest
    2842
    2843        values = self._parse_derived_table_values()
    2844        if values:
    2845            return values
    2846
    2847        subquery = self._parse_select(table=True)
    2848        if subquery:
    2849            if not subquery.args.get("pivots"):
    2850                subquery.set("pivots", self._parse_pivots())
    2851            return subquery
    2852
    2853        bracket = parse_bracket and self._parse_bracket(None)
    2854        bracket = self.expression(exp.Table, this=bracket) if bracket else None
    2855        this = t.cast(
    2856            exp.Expression,
    2857            bracket
    2858            or self._parse_bracket(
    2859                self._parse_table_parts(schema=schema, is_db_reference=is_db_reference)
    2860            ),
    2861        )
    2862
    2863        if schema:
    2864            return self._parse_schema(this=this)
    2865
    2866        version = self._parse_version()
    2867
    2868        if version:
    2869            this.set("version", version)
    2870
    2871        if self.dialect.ALIAS_POST_TABLESAMPLE:
    2872            table_sample = self._parse_table_sample()
    2873
    2874        alias = self._parse_table_alias(alias_tokens=alias_tokens or self.TABLE_ALIAS_TOKENS)
    2875        if alias:
    2876            this.set("alias", alias)
    2877
    2878        if isinstance(this, exp.Table) and self._match_text_seq("AT"):
    2879            return self.expression(
    2880                exp.AtIndex, this=this.to_column(copy=False), expression=self._parse_id_var()
    2881            )
    2882
    2883        this.set("hints", self._parse_table_hints())
    2884
    2885        if not this.args.get("pivots"):
    2886            this.set("pivots", self._parse_pivots())
    2887
    2888        if not self.dialect.ALIAS_POST_TABLESAMPLE:
    2889            table_sample = self._parse_table_sample()
    2890
    2891        if table_sample:
    2892            table_sample.set("this", this)
    2893            this = table_sample
    2894
    2895        if joins:
    2896            for join in iter(self._parse_join, None):
    2897                this.append("joins", join)
    2898
    2899        if self._match_pair(TokenType.WITH, TokenType.ORDINALITY):
    2900            this.set("ordinality", True)
    2901            this.set("alias", self._parse_table_alias())
    2902
    2903        return this
    2904
    2905    def _parse_version(self) -> t.Optional[exp.Version]:
    2906        if self._match(TokenType.TIMESTAMP_SNAPSHOT):
    2907            this = "TIMESTAMP"
    2908        elif self._match(TokenType.VERSION_SNAPSHOT):
    2909            this = "VERSION"
    2910        else:
    2911            return None
    2912
    2913        if self._match_set((TokenType.FROM, TokenType.BETWEEN)):
    2914            kind = self._prev.text.upper()
    2915            start = self._parse_bitwise()
    2916            self._match_texts(("TO", "AND"))
    2917            end = self._parse_bitwise()
    2918            expression: t.Optional[exp.Expression] = self.expression(
    2919                exp.Tuple, expressions=[start, end]
    2920            )
    2921        elif self._match_text_seq("CONTAINED", "IN"):
    2922            kind = "CONTAINED IN"
    2923            expression = self.expression(
    2924                exp.Tuple, expressions=self._parse_wrapped_csv(self._parse_bitwise)
    2925            )
    2926        elif self._match(TokenType.ALL):
    2927            kind = "ALL"
    2928            expression = None
    2929        else:
    2930            self._match_text_seq("AS", "OF")
    2931            kind = "AS OF"
    2932            expression = self._parse_type()
    2933
    2934        return self.expression(exp.Version, this=this, expression=expression, kind=kind)
    2935
    2936    def _parse_unnest(self, with_alias: bool = True) -> t.Optional[exp.Unnest]:
    2937        if not self._match(TokenType.UNNEST):
    2938            return None
    2939
    2940        expressions = self._parse_wrapped_csv(self._parse_equality)
    2941        offset = self._match_pair(TokenType.WITH, TokenType.ORDINALITY)
    2942
    2943        alias = self._parse_table_alias() if with_alias else None
    2944
    2945        if alias:
    2946            if self.dialect.UNNEST_COLUMN_ONLY:
    2947                if alias.args.get("columns"):
    2948                    self.raise_error("Unexpected extra column alias in unnest.")
    2949
    2950                alias.set("columns", [alias.this])
    2951                alias.set("this", None)
    2952
    2953            columns = alias.args.get("columns") or []
    2954            if offset and len(expressions) < len(columns):
    2955                offset = columns.pop()
    2956
    2957        if not offset and self._match_pair(TokenType.WITH, TokenType.OFFSET):
    2958            self._match(TokenType.ALIAS)
    2959            offset = self._parse_id_var(
    2960                any_token=False, tokens=self.UNNEST_OFFSET_ALIAS_TOKENS
    2961            ) or exp.to_identifier("offset")
    2962
    2963        return self.expression(exp.Unnest, expressions=expressions, alias=alias, offset=offset)
    2964
    2965    def _parse_derived_table_values(self) -> t.Optional[exp.Values]:
    2966        is_derived = self._match_pair(TokenType.L_PAREN, TokenType.VALUES)
    2967        if not is_derived and not self._match(TokenType.VALUES):
    2968            return None
    2969
    2970        expressions = self._parse_csv(self._parse_value)
    2971        alias = self._parse_table_alias()
    2972
    2973        if is_derived:
    2974            self._match_r_paren()
    2975
    2976        return self.expression(
    2977            exp.Values, expressions=expressions, alias=alias or self._parse_table_alias()
    2978        )
    2979
    2980    def _parse_table_sample(self, as_modifier: bool = False) -> t.Optional[exp.TableSample]:
    2981        if not self._match(TokenType.TABLE_SAMPLE) and not (
    2982            as_modifier and self._match_text_seq("USING", "SAMPLE")
    2983        ):
    2984            return None
    2985
    2986        bucket_numerator = None
    2987        bucket_denominator = None
    2988        bucket_field = None
    2989        percent = None
    2990        size = None
    2991        seed = None
    2992
    2993        method = self._parse_var(tokens=(TokenType.ROW,), upper=True)
    2994        matched_l_paren = self._match(TokenType.L_PAREN)
    2995
    2996        if self.TABLESAMPLE_CSV:
    2997            num = None
    2998            expressions = self._parse_csv(self._parse_primary)
    2999        else:
    3000            expressions = None
    3001            num = (
    3002                self._parse_factor()
    3003                if self._match(TokenType.NUMBER, advance=False)
    3004                else self._parse_primary() or self._parse_placeholder()
    3005            )
    3006
    3007        if self._match_text_seq("BUCKET"):
    3008            bucket_numerator = self._parse_number()
    3009            self._match_text_seq("OUT", "OF")
    3010            bucket_denominator = bucket_denominator = self._parse_number()
    3011            self._match(TokenType.ON)
    3012            bucket_field = self._parse_field()
    3013        elif self._match_set((TokenType.PERCENT, TokenType.MOD)):
    3014            percent = num
    3015        elif self._match(TokenType.ROWS) or not self.dialect.TABLESAMPLE_SIZE_IS_PERCENT:
    3016            size = num
    3017        else:
    3018            percent = num
    3019
    3020        if matched_l_paren:
    3021            self._match_r_paren()
    3022
    3023        if self._match(TokenType.L_PAREN):
    3024            method = self._parse_var(upper=True)
    3025            seed = self._match(TokenType.COMMA) and self._parse_number()
    3026            self._match_r_paren()
    3027        elif self._match_texts(("SEED", "REPEATABLE")):
    3028            seed = self._parse_wrapped(self._parse_number)
    3029
    3030        return self.expression(
    3031            exp.TableSample,
    3032            expressions=expressions,
    3033            method=method,
    3034            bucket_numerator=bucket_numerator,
    3035            bucket_denominator=bucket_denominator,
    3036            bucket_field=bucket_field,
    3037            percent=percent,
    3038            size=size,
    3039            seed=seed,
    3040        )
    3041
    3042    def _parse_pivots(self) -> t.Optional[t.List[exp.Pivot]]:
    3043        return list(iter(self._parse_pivot, None)) or None
    3044
    3045    def _parse_joins(self) -> t.Optional[t.List[exp.Join]]:
    3046        return list(iter(self._parse_join, None)) or None
    3047
    3048    # https://duckdb.org/docs/sql/statements/pivot
    3049    def _parse_simplified_pivot(self) -> exp.Pivot:
    3050        def _parse_on() -> t.Optional[exp.Expression]:
    3051            this = self._parse_bitwise()
    3052            return self._parse_in(this) if self._match(TokenType.IN) else this
    3053
    3054        this = self._parse_table()
    3055        expressions = self._match(TokenType.ON) and self._parse_csv(_parse_on)
    3056        using = self._match(TokenType.USING) and self._parse_csv(
    3057            lambda: self._parse_alias(self._parse_function())
    3058        )
    3059        group = self._parse_group()
    3060        return self.expression(
    3061            exp.Pivot, this=this, expressions=expressions, using=using, group=group
    3062        )
    3063
    3064    def _parse_pivot_in(self) -> exp.In:
    3065        def _parse_aliased_expression() -> t.Optional[exp.Expression]:
    3066            this = self._parse_conjunction()
    3067
    3068            self._match(TokenType.ALIAS)
    3069            alias = self._parse_field()
    3070            if alias:
    3071                return self.expression(exp.PivotAlias, this=this, alias=alias)
    3072
    3073            return this
    3074
    3075        value = self._parse_column()
    3076
    3077        if not self._match_pair(TokenType.IN, TokenType.L_PAREN):
    3078            self.raise_error("Expecting IN (")
    3079
    3080        aliased_expressions = self._parse_csv(_parse_aliased_expression)
    3081
    3082        self._match_r_paren()
    3083        return self.expression(exp.In, this=value, expressions=aliased_expressions)
    3084
    3085    def _parse_pivot(self) -> t.Optional[exp.Pivot]:
    3086        index = self._index
    3087        include_nulls = None
    3088
    3089        if self._match(TokenType.PIVOT):
    3090            unpivot = False
    3091        elif self._match(TokenType.UNPIVOT):
    3092            unpivot = True
    3093
    3094            # https://docs.databricks.com/en/sql/language-manual/sql-ref-syntax-qry-select-unpivot.html#syntax
    3095            if self._match_text_seq("INCLUDE", "NULLS"):
    3096                include_nulls = True
    3097            elif self._match_text_seq("EXCLUDE", "NULLS"):
    3098                include_nulls = False
    3099        else:
    3100            return None
    3101
    3102        expressions = []
    3103
    3104        if not self._match(TokenType.L_PAREN):
    3105            self._retreat(index)
    3106            return None
    3107
    3108        if unpivot:
    3109            expressions = self._parse_csv(self._parse_column)
    3110        else:
    3111            expressions = self._parse_csv(lambda: self._parse_alias(self._parse_function()))
    3112
    3113        if not expressions:
    3114            self.raise_error("Failed to parse PIVOT's aggregation list")
    3115
    3116        if not self._match(TokenType.FOR):
    3117            self.raise_error("Expecting FOR")
    3118
    3119        field = self._parse_pivot_in()
    3120
    3121        self._match_r_paren()
    3122
    3123        pivot = self.expression(
    3124            exp.Pivot,
    3125            expressions=expressions,
    3126            field=field,
    3127            unpivot=unpivot,
    3128            include_nulls=include_nulls,
    3129        )
    3130
    3131        if not self._match_set((TokenType.PIVOT, TokenType.UNPIVOT), advance=False):
    3132            pivot.set("alias", self._parse_table_alias())
    3133
    3134        if not unpivot:
    3135            names = self._pivot_column_names(t.cast(t.List[exp.Expression], expressions))
    3136
    3137            columns: t.List[exp.Expression] = []
    3138            for fld in pivot.args["field"].expressions:
    3139                field_name = fld.sql() if self.IDENTIFY_PIVOT_STRINGS else fld.alias_or_name
    3140                for name in names:
    3141                    if self.PREFIXED_PIVOT_COLUMNS:
    3142                        name = f"{name}_{field_name}" if name else field_name
    3143                    else:
    3144                        name = f"{field_name}_{name}" if name else field_name
    3145
    3146                    columns.append(exp.to_identifier(name))
    3147
    3148            pivot.set("columns", columns)
    3149
    3150        return pivot
    3151
    3152    def _pivot_column_names(self, aggregations: t.List[exp.Expression]) -> t.List[str]:
    3153        return [agg.alias for agg in aggregations]
    3154
    3155    def _parse_where(self, skip_where_token: bool = False) -> t.Optional[exp.Where]:
    3156        if not skip_where_token and not self._match(TokenType.WHERE):
    3157            return None
    3158
    3159        return self.expression(
    3160            exp.Where, comments=self._prev_comments, this=self._parse_conjunction()
    3161        )
    3162
    3163    def _parse_group(self, skip_group_by_token: bool = False) -> t.Optional[exp.Group]:
    3164        if not skip_group_by_token and not self._match(TokenType.GROUP_BY):
    3165            return None
    3166
    3167        elements = defaultdict(list)
    3168
    3169        if self._match(TokenType.ALL):
    3170            return self.expression(exp.Group, all=True)
    3171
    3172        while True:
    3173            expressions = self._parse_csv(self._parse_conjunction)
    3174            if expressions:
    3175                elements["expressions"].extend(expressions)
    3176
    3177            grouping_sets = self._parse_grouping_sets()
    3178            if grouping_sets:
    3179                elements["grouping_sets"].extend(grouping_sets)
    3180
    3181            rollup = None
    3182            cube = None
    3183            totals = None
    3184
    3185            index = self._index
    3186            with_ = self._match(TokenType.WITH)
    3187            if self._match(TokenType.ROLLUP):
    3188                rollup = with_ or self._parse_wrapped_csv(self._parse_column)
    3189                elements["rollup"].extend(ensure_list(rollup))
    3190
    3191            if self._match(TokenType.CUBE):
    3192                cube = with_ or self._parse_wrapped_csv(self._parse_column)
    3193                elements["cube"].extend(ensure_list(cube))
    3194
    3195            if self._match_text_seq("TOTALS"):
    3196                totals = True
    3197                elements["totals"] = True  # type: ignore
    3198
    3199            if not (grouping_sets or rollup or cube or totals):
    3200                if with_:
    3201                    self._retreat(index)
    3202                break
    3203
    3204        return self.expression(exp.Group, **elements)  # type: ignore
    3205
    3206    def _parse_grouping_sets(self) -> t.Optional[t.List[exp.Expression]]:
    3207        if not self._match(TokenType.GROUPING_SETS):
    3208            return None
    3209
    3210        return self._parse_wrapped_csv(self._parse_grouping_set)
    3211
    3212    def _parse_grouping_set(self) -> t.Optional[exp.Expression]:
    3213        if self._match(TokenType.L_PAREN):
    3214            grouping_set = self._parse_csv(self._parse_column)
    3215            self._match_r_paren()
    3216            return self.expression(exp.Tuple, expressions=grouping_set)
    3217
    3218        return self._parse_column()
    3219
    3220    def _parse_having(self, skip_having_token: bool = False) -> t.Optional[exp.Having]:
    3221        if not skip_having_token and not self._match(TokenType.HAVING):
    3222            return None
    3223        return self.expression(exp.Having, this=self._parse_conjunction())
    3224
    3225    def _parse_qualify(self) -> t.Optional[exp.Qualify]:
    3226        if not self._match(TokenType.QUALIFY):
    3227            return None
    3228        return self.expression(exp.Qualify, this=self._parse_conjunction())
    3229
    3230    def _parse_connect(self, skip_start_token: bool = False) -> t.Optional[exp.Connect]:
    3231        if skip_start_token:
    3232            start = None
    3233        elif self._match(TokenType.START_WITH):
    3234            start = self._parse_conjunction()
    3235        else:
    3236            return None
    3237
    3238        self._match(TokenType.CONNECT_BY)
    3239        self.NO_PAREN_FUNCTION_PARSERS["PRIOR"] = lambda self: self.expression(
    3240            exp.Prior, this=self._parse_bitwise()
    3241        )
    3242        connect = self._parse_conjunction()
    3243        self.NO_PAREN_FUNCTION_PARSERS.pop("PRIOR")
    3244
    3245        if not start and self._match(TokenType.START_WITH):
    3246            start = self._parse_conjunction()
    3247
    3248        return self.expression(exp.Connect, start=start, connect=connect)
    3249
    3250    def _parse_name_as_expression(self) -> exp.Alias:
    3251        return self.expression(
    3252            exp.Alias,
    3253            alias=self._parse_id_var(any_token=True),
    3254            this=self._match(TokenType.ALIAS) and self._parse_conjunction(),
    3255        )
    3256
    3257    def _parse_interpolate(self) -> t.Optional[t.List[exp.Expression]]:
    3258        if self._match_text_seq("INTERPOLATE"):
    3259            return self._parse_wrapped_csv(self._parse_name_as_expression)
    3260        return None
    3261
    3262    def _parse_order(
    3263        self, this: t.Optional[exp.Expression] = None, skip_order_token: bool = False
    3264    ) -> t.Optional[exp.Expression]:
    3265        siblings = None
    3266        if not skip_order_token and not self._match(TokenType.ORDER_BY):
    3267            if not self._match(TokenType.ORDER_SIBLINGS_BY):
    3268                return this
    3269
    3270            siblings = True
    3271
    3272        return self.expression(
    3273            exp.Order,
    3274            this=this,
    3275            expressions=self._parse_csv(self._parse_ordered),
    3276            interpolate=self._parse_interpolate(),
    3277            siblings=siblings,
    3278        )
    3279
    3280    def _parse_sort(self, exp_class: t.Type[E], token: TokenType) -> t.Optional[E]:
    3281        if not self._match(token):
    3282            return None
    3283        return self.expression(exp_class, expressions=self._parse_csv(self._parse_ordered))
    3284
    3285    def _parse_ordered(self, parse_method: t.Optional[t.Callable] = None) -> exp.Ordered:
    3286        this = parse_method() if parse_method else self._parse_conjunction()
    3287
    3288        asc = self._match(TokenType.ASC)
    3289        desc = self._match(TokenType.DESC) or (asc and False)
    3290
    3291        is_nulls_first = self._match_text_seq("NULLS", "FIRST")
    3292        is_nulls_last = self._match_text_seq("NULLS", "LAST")
    3293
    3294        nulls_first = is_nulls_first or False
    3295        explicitly_null_ordered = is_nulls_first or is_nulls_last
    3296
    3297        if (
    3298            not explicitly_null_ordered
    3299            and (
    3300                (not desc and self.dialect.NULL_ORDERING == "nulls_are_small")
    3301                or (desc and self.dialect.NULL_ORDERING != "nulls_are_small")
    3302            )
    3303            and self.dialect.NULL_ORDERING != "nulls_are_last"
    3304        ):
    3305            nulls_first = True
    3306
    3307        if self._match_text_seq("WITH", "FILL"):
    3308            with_fill = self.expression(
    3309                exp.WithFill,
    3310                **{  # type: ignore
    3311                    "from": self._match(TokenType.FROM) and self._parse_bitwise(),
    3312                    "to": self._match_text_seq("TO") and self._parse_bitwise(),
    3313                    "step": self._match_text_seq("STEP") and self._parse_bitwise(),
    3314                },
    3315            )
    3316        else:
    3317            with_fill = None
    3318
    3319        return self.expression(
    3320            exp.Ordered, this=this, desc=desc, nulls_first=nulls_first, with_fill=with_fill
    3321        )
    3322
    3323    def _parse_limit(
    3324        self, this: t.Optional[exp.Expression] = None, top: bool = False
    3325    ) -> t.Optional[exp.Expression]:
    3326        if self._match(TokenType.TOP if top else TokenType.LIMIT):
    3327            comments = self._prev_comments
    3328            if top:
    3329                limit_paren = self._match(TokenType.L_PAREN)
    3330                expression = self._parse_term() if limit_paren else self._parse_number()
    3331
    3332                if limit_paren:
    3333                    self._match_r_paren()
    3334            else:
    3335                expression = self._parse_term()
    3336
    3337            if self._match(TokenType.COMMA):
    3338                offset = expression
    3339                expression = self._parse_term()
    3340            else:
    3341                offset = None
    3342
    3343            limit_exp = self.expression(
    3344                exp.Limit, this=this, expression=expression, offset=offset, comments=comments
    3345            )
    3346
    3347            return limit_exp
    3348
    3349        if self._match(TokenType.FETCH):
    3350            direction = self._match_set((TokenType.FIRST, TokenType.NEXT))
    3351            direction = self._prev.text.upper() if direction else "FIRST"
    3352
    3353            count = self._parse_field(tokens=self.FETCH_TOKENS)
    3354            percent = self._match(TokenType.PERCENT)
    3355
    3356            self._match_set((TokenType.ROW, TokenType.ROWS))
    3357
    3358            only = self._match_text_seq("ONLY")
    3359            with_ties = self._match_text_seq("WITH", "TIES")
    3360
    3361            if only and with_ties:
    3362                self.raise_error("Cannot specify both ONLY and WITH TIES in FETCH clause")
    3363
    3364            return self.expression(
    3365                exp.Fetch,
    3366                direction=direction,
    3367                count=count,
    3368                percent=percent,
    3369                with_ties=with_ties,
    3370            )
    3371
    3372        return this
    3373
    3374    def _parse_offset(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
    3375        if not self._match(TokenType.OFFSET):
    3376            return this
    3377
    3378        count = self._parse_term()
    3379        self._match_set((TokenType.ROW, TokenType.ROWS))
    3380        return self.expression(exp.Offset, this=this, expression=count)
    3381
    3382    def _parse_locks(self) -> t.List[exp.Lock]:
    3383        locks = []
    3384        while True:
    3385            if self._match_text_seq("FOR", "UPDATE"):
    3386                update = True
    3387            elif self._match_text_seq("FOR", "SHARE") or self._match_text_seq(
    3388                "LOCK", "IN", "SHARE", "MODE"
    3389            ):
    3390                update = False
    3391            else:
    3392                break
    3393
    3394            expressions = None
    3395            if self._match_text_seq("OF"):
    3396                expressions = self._parse_csv(lambda: self._parse_table(schema=True))
    3397
    3398            wait: t.Optional[bool | exp.Expression] = None
    3399            if self._match_text_seq("NOWAIT"):
    3400                wait = True
    3401            elif self._match_text_seq("WAIT"):
    3402                wait = self._parse_primary()
    3403            elif self._match_text_seq("SKIP", "LOCKED"):
    3404                wait = False
    3405
    3406            locks.append(
    3407                self.expression(exp.Lock, update=update, expressions=expressions, wait=wait)
    3408            )
    3409
    3410        return locks
    3411
    3412    def _parse_set_operations(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    3413        while this and self._match_set(self.SET_OPERATIONS):
    3414            token_type = self._prev.token_type
    3415
    3416            if token_type == TokenType.UNION:
    3417                operation = exp.Union
    3418            elif token_type == TokenType.EXCEPT:
    3419                operation = exp.Except
    3420            else:
    3421                operation = exp.Intersect
    3422
    3423            comments = self._prev.comments
    3424            distinct = self._match(TokenType.DISTINCT) or not self._match(TokenType.ALL)
    3425            by_name = self._match_text_seq("BY", "NAME")
    3426            expression = self._parse_select(nested=True, parse_set_operation=False)
    3427
    3428            this = self.expression(
    3429                operation,
    3430                comments=comments,
    3431                this=this,
    3432                distinct=distinct,
    3433                by_name=by_name,
    3434                expression=expression,
    3435            )
    3436
    3437        if isinstance(this, exp.Union) and self.MODIFIERS_ATTACHED_TO_UNION:
    3438            expression = this.expression
    3439
    3440            if expression:
    3441                for arg in self.UNION_MODIFIERS:
    3442                    expr = expression.args.get(arg)
    3443                    if expr:
    3444                        this.set(arg, expr.pop())
    3445
    3446        return this
    3447
    3448    def _parse_expression(self) -> t.Optional[exp.Expression]:
    3449        return self._parse_alias(self._parse_conjunction())
    3450
    3451    def _parse_conjunction(self) -> t.Optional[exp.Expression]:
    3452        return self._parse_tokens(self._parse_equality, self.CONJUNCTION)
    3453
    3454    def _parse_equality(self) -> t.Optional[exp.Expression]:
    3455        return self._parse_tokens(self._parse_comparison, self.EQUALITY)
    3456
    3457    def _parse_comparison(self) -> t.Optional[exp.Expression]:
    3458        return self._parse_tokens(self._parse_range, self.COMPARISON)
    3459
    3460    def _parse_range(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
    3461        this = this or self._parse_bitwise()
    3462        negate = self._match(TokenType.NOT)
    3463
    3464        if self._match_set(self.RANGE_PARSERS):
    3465            expression = self.RANGE_PARSERS[self._prev.token_type](self, this)
    3466            if not expression:
    3467                return this
    3468
    3469            this = expression
    3470        elif self._match(TokenType.ISNULL):
    3471            this = self.expression(exp.Is, this=this, expression=exp.Null())
    3472
    3473        # Postgres supports ISNULL and NOTNULL for conditions.
    3474        # https://blog.andreiavram.ro/postgresql-null-composite-type/
    3475        if self._match(TokenType.NOTNULL):
    3476            this = self.expression(exp.Is, this=this, expression=exp.Null())
    3477            this = self.expression(exp.Not, this=this)
    3478
    3479        if negate:
    3480            this = self.expression(exp.Not, this=this)
    3481
    3482        if self._match(TokenType.IS):
    3483            this = self._parse_is(this)
    3484
    3485        return this
    3486
    3487    def _parse_is(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    3488        index = self._index - 1
    3489        negate = self._match(TokenType.NOT)
    3490
    3491        if self._match_text_seq("DISTINCT", "FROM"):
    3492            klass = exp.NullSafeEQ if negate else exp.NullSafeNEQ
    3493            return self.expression(klass, this=this, expression=self._parse_conjunction())
    3494
    3495        expression = self._parse_null() or self._parse_boolean()
    3496        if not expression:
    3497            self._retreat(index)
    3498            return None
    3499
    3500        this = self.expression(exp.Is, this=this, expression=expression)
    3501        return self.expression(exp.Not, this=this) if negate else this
    3502
    3503    def _parse_in(self, this: t.Optional[exp.Expression], alias: bool = False) -> exp.In:
    3504        unnest = self._parse_unnest(with_alias=False)
    3505        if unnest:
    3506            this = self.expression(exp.In, this=this, unnest=unnest)
    3507        elif self._match_set((TokenType.L_PAREN, TokenType.L_BRACKET)):
    3508            matched_l_paren = self._prev.token_type == TokenType.L_PAREN
    3509            expressions = self._parse_csv(lambda: self._parse_select_or_expression(alias=alias))
    3510
    3511            if len(expressions) == 1 and isinstance(expressions[0], exp.Subqueryable):
    3512                this = self.expression(exp.In, this=this, query=expressions[0])
    3513            else:
    3514                this = self.expression(exp.In, this=this, expressions=expressions)
    3515
    3516            if matched_l_paren:
    3517                self._match_r_paren(this)
    3518            elif not self._match(TokenType.R_BRACKET, expression=this):
    3519                self.raise_error("Expecting ]")
    3520        else:
    3521            this = self.expression(exp.In, this=this, field=self._parse_field())
    3522
    3523        return this
    3524
    3525    def _parse_between(self, this: t.Optional[exp.Expression]) -> exp.Between:
    3526        low = self._parse_bitwise()
    3527        self._match(TokenType.AND)
    3528        high = self._parse_bitwise()
    3529        return self.expression(exp.Between, this=this, low=low, high=high)
    3530
    3531    def _parse_escape(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    3532        if not self._match(TokenType.ESCAPE):
    3533            return this
    3534        return self.expression(exp.Escape, this=this, expression=self._parse_string())
    3535
    3536    def _parse_interval(self, match_interval: bool = True) -> t.Optional[exp.Interval]:
    3537        index = self._index
    3538
    3539        if not self._match(TokenType.INTERVAL) and match_interval:
    3540            return None
    3541
    3542        if self._match(TokenType.STRING, advance=False):
    3543            this = self._parse_primary()
    3544        else:
    3545            this = self._parse_term()
    3546
    3547        if not this or (
    3548            isinstance(this, exp.Column)
    3549            and not this.table
    3550            and not this.this.quoted
    3551            and this.name.upper() == "IS"
    3552        ):
    3553            self._retreat(index)
    3554            return None
    3555
    3556        unit = self._parse_function() or (
    3557            not self._match(TokenType.ALIAS, advance=False)
    3558            and self._parse_var(any_token=True, upper=True)
    3559        )
    3560
    3561        # Most dialects support, e.g., the form INTERVAL '5' day, thus we try to parse
    3562        # each INTERVAL expression into this canonical form so it's easy to transpile
    3563        if this and this.is_number:
    3564            this = exp.Literal.string(this.name)
    3565        elif this and this.is_string:
    3566            parts = this.name.split()
    3567
    3568            if len(parts) == 2:
    3569                if unit:
    3570                    # This is not actually a unit, it's something else (e.g. a "window side")
    3571                    unit = None
    3572                    self._retreat(self._index - 1)
    3573
    3574                this = exp.Literal.string(parts[0])
    3575                unit = self.expression(exp.Var, this=parts[1].upper())
    3576
    3577        return self.expression(exp.Interval, this=this, unit=unit)
    3578
    3579    def _parse_bitwise(self) -> t.Optional[exp.Expression]:
    3580        this = self._parse_term()
    3581
    3582        while True:
    3583            if self._match_set(self.BITWISE):
    3584                this = self.expression(
    3585                    self.BITWISE[self._prev.token_type],
    3586                    this=this,
    3587                    expression=self._parse_term(),
    3588                )
    3589            elif self.dialect.DPIPE_IS_STRING_CONCAT and self._match(TokenType.DPIPE):
    3590                this = self.expression(
    3591                    exp.DPipe,
    3592                    this=this,
    3593                    expression=self._parse_term(),
    3594                    safe=not self.dialect.STRICT_STRING_CONCAT,
    3595                )
    3596            elif self._match(TokenType.DQMARK):
    3597                this = self.expression(exp.Coalesce, this=this, expressions=self._parse_term())
    3598            elif self._match_pair(TokenType.LT, TokenType.LT):
    3599                this = self.expression(
    3600                    exp.BitwiseLeftShift, this=this, expression=self._parse_term()
    3601                )
    3602            elif self._match_pair(TokenType.GT, TokenType.GT):
    3603                this = self.expression(
    3604                    exp.BitwiseRightShift, this=this, expression=self._parse_term()
    3605                )
    3606            else:
    3607                break
    3608
    3609        return this
    3610
    3611    def _parse_term(self) -> t.Optional[exp.Expression]:
    3612        return self._parse_tokens(self._parse_factor, self.TERM)
    3613
    3614    def _parse_factor(self) -> t.Optional[exp.Expression]:
    3615        parse_method = self._parse_exponent if self.EXPONENT else self._parse_unary
    3616        this = parse_method()
    3617
    3618        while self._match_set(self.FACTOR):
    3619            this = self.expression(
    3620                self.FACTOR[self._prev.token_type],
    3621                this=this,
    3622                comments=self._prev_comments,
    3623                expression=parse_method(),
    3624            )
    3625            if isinstance(this, exp.Div):
    3626                this.args["typed"] = self.dialect.TYPED_DIVISION
    3627                this.args["safe"] = self.dialect.SAFE_DIVISION
    3628
    3629        return this
    3630
    3631    def _parse_exponent(self) -> t.Optional[exp.Expression]:
    3632        return self._parse_tokens(self._parse_unary, self.EXPONENT)
    3633
    3634    def _parse_unary(self) -> t.Optional[exp.Expression]:
    3635        if self._match_set(self.UNARY_PARSERS):
    3636            return self.UNARY_PARSERS[self._prev.token_type](self)
    3637        return self._parse_at_time_zone(self._parse_type())
    3638
    3639    def _parse_type(self, parse_interval: bool = True) -> t.Optional[exp.Expression]:
    3640        interval = parse_interval and self._parse_interval()
    3641        if interval:
    3642            # Convert INTERVAL 'val_1' unit_1 ... 'val_n' unit_n into a sum of intervals
    3643            while self._match_set((TokenType.STRING, TokenType.NUMBER), advance=False):
    3644                interval = self.expression(  # type: ignore
    3645                    exp.Add, this=interval, expression=self._parse_interval(match_interval=False)
    3646                )
    3647
    3648            return interval
    3649
    3650        index = self._index
    3651        data_type = self._parse_types(check_func=True, allow_identifiers=False)
    3652        this = self._parse_column()
    3653
    3654        if data_type:
    3655            if isinstance(this, exp.Literal):
    3656                parser = self.TYPE_LITERAL_PARSERS.get(data_type.this)
    3657                if parser:
    3658                    return parser(self, this, data_type)
    3659                return self.expression(exp.Cast, this=this, to=data_type)
    3660            if not data_type.expressions:
    3661                self._retreat(index)
    3662                return self._parse_column()
    3663            return self._parse_column_ops(data_type)
    3664
    3665        return this and self._parse_column_ops(this)
    3666
    3667    def _parse_type_size(self) -> t.Optional[exp.DataTypeParam]:
    3668        this = self._parse_type()
    3669        if not this:
    3670            return None
    3671
    3672        return self.expression(
    3673            exp.DataTypeParam, this=this, expression=self._parse_var(any_token=True)
    3674        )
    3675
    3676    def _parse_types(
    3677        self, check_func: bool = False, schema: bool = False, allow_identifiers: bool = True
    3678    ) -> t.Optional[exp.Expression]:
    3679        index = self._index
    3680
    3681        prefix = self._match_text_seq("SYSUDTLIB", ".")
    3682
    3683        if not self._match_set(self.TYPE_TOKENS):
    3684            identifier = allow_identifiers and self._parse_id_var(
    3685                any_token=False, tokens=(TokenType.VAR,)
    3686            )
    3687            if identifier:
    3688                tokens = self.dialect.tokenize(identifier.name)
    3689
    3690                if len(tokens) != 1:
    3691                    self.raise_error("Unexpected identifier", self._prev)
    3692
    3693                if tokens[0].token_type in self.TYPE_TOKENS:
    3694                    self._prev = tokens[0]
    3695                elif self.dialect.SUPPORTS_USER_DEFINED_TYPES:
    3696                    type_name = identifier.name
    3697
    3698                    while self._match(TokenType.DOT):
    3699                        type_name = f"{type_name}.{self._advance_any() and self._prev.text}"
    3700
    3701                    return exp.DataType.build(type_name, udt=True)
    3702                else:
    3703                    self._retreat(self._index - 1)
    3704                    return None
    3705            else:
    3706                return None
    3707
    3708        type_token = self._prev.token_type
    3709
    3710        if type_token == TokenType.PSEUDO_TYPE:
    3711            return self.expression(exp.PseudoType, this=self._prev.text.upper())
    3712
    3713        if type_token == TokenType.OBJECT_IDENTIFIER:
    3714            return self.expression(exp.ObjectIdentifier, this=self._prev.text.upper())
    3715
    3716        nested = type_token in self.NESTED_TYPE_TOKENS
    3717        is_struct = type_token in self.STRUCT_TYPE_TOKENS
    3718        is_aggregate = type_token in self.AGGREGATE_TYPE_TOKENS
    3719        expressions = None
    3720        maybe_func = False
    3721
    3722        if self._match(TokenType.L_PAREN):
    3723            if is_struct:
    3724                expressions = self._parse_csv(self._parse_struct_types)
    3725            elif nested:
    3726                expressions = self._parse_csv(
    3727                    lambda: self._parse_types(
    3728                        check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
    3729                    )
    3730                )
    3731            elif type_token in self.ENUM_TYPE_TOKENS:
    3732                expressions = self._parse_csv(self._parse_equality)
    3733            elif is_aggregate:
    3734                func_or_ident = self._parse_function(anonymous=True) or self._parse_id_var(
    3735                    any_token=False, tokens=(TokenType.VAR,)
    3736                )
    3737                if not func_or_ident or not self._match(TokenType.COMMA):
    3738                    return None
    3739                expressions = self._parse_csv(
    3740                    lambda: self._parse_types(
    3741                        check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
    3742                    )
    3743                )
    3744                expressions.insert(0, func_or_ident)
    3745            else:
    3746                expressions = self._parse_csv(self._parse_type_size)
    3747
    3748            if not expressions or not self._match(TokenType.R_PAREN):
    3749                self._retreat(index)
    3750                return None
    3751
    3752            maybe_func = True
    3753
    3754        this: t.Optional[exp.Expression] = None
    3755        values: t.Optional[t.List[exp.Expression]] = None
    3756
    3757        if nested and self._match(TokenType.LT):
    3758            if is_struct:
    3759                expressions = self._parse_csv(lambda: self._parse_struct_types(type_required=True))
    3760            else:
    3761                expressions = self._parse_csv(
    3762                    lambda: self._parse_types(
    3763                        check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
    3764                    )
    3765                )
    3766
    3767            if not self._match(TokenType.GT):
    3768                self.raise_error("Expecting >")
    3769
    3770            if self._match_set((TokenType.L_BRACKET, TokenType.L_PAREN)):
    3771                values = self._parse_csv(self._parse_conjunction)
    3772                self._match_set((TokenType.R_BRACKET, TokenType.R_PAREN))
    3773
    3774        if type_token in self.TIMESTAMPS:
    3775            if self._match_text_seq("WITH", "TIME", "ZONE"):
    3776                maybe_func = False
    3777                tz_type = (
    3778                    exp.DataType.Type.TIMETZ
    3779                    if type_token in self.TIMES
    3780                    else exp.DataType.Type.TIMESTAMPTZ
    3781                )
    3782                this = exp.DataType(this=tz_type, expressions=expressions)
    3783            elif self._match_text_seq("WITH", "LOCAL", "TIME", "ZONE"):
    3784                maybe_func = False
    3785                this = exp.DataType(this=exp.DataType.Type.TIMESTAMPLTZ, expressions=expressions)
    3786            elif self._match_text_seq("WITHOUT", "TIME", "ZONE"):
    3787                maybe_func = False
    3788        elif type_token == TokenType.INTERVAL:
    3789            unit = self._parse_var()
    3790
    3791            if self._match_text_seq("TO"):
    3792                span = [exp.IntervalSpan(this=unit, expression=self._parse_var())]
    3793            else:
    3794                span = None
    3795
    3796            if span or not unit:
    3797                this = self.expression(
    3798                    exp.DataType, this=exp.DataType.Type.INTERVAL, expressions=span
    3799                )
    3800            else:
    3801                this = self.expression(exp.DataType, this=self.expression(exp.Interval, unit=unit))
    3802
    3803        if maybe_func and check_func:
    3804            index2 = self._index
    3805            peek = self._parse_string()
    3806
    3807            if not peek:
    3808                self._retreat(index)
    3809                return None
    3810
    3811            self._retreat(index2)
    3812
    3813        if not this:
    3814            if self._match_text_seq("UNSIGNED"):
    3815                unsigned_type_token = self.SIGNED_TO_UNSIGNED_TYPE_TOKEN.get(type_token)
    3816                if not unsigned_type_token:
    3817                    self.raise_error(f"Cannot convert {type_token.value} to unsigned.")
    3818
    3819                type_token = unsigned_type_token or type_token
    3820
    3821            this = exp.DataType(
    3822                this=exp.DataType.Type[type_token.value],
    3823                expressions=expressions,
    3824                nested=nested,
    3825                values=values,
    3826                prefix=prefix,
    3827            )
    3828
    3829        while self._match_pair(TokenType.L_BRACKET, TokenType.R_BRACKET):
    3830            this = exp.DataType(this=exp.DataType.Type.ARRAY, expressions=[this], nested=True)
    3831
    3832        return this
    3833
    3834    def _parse_struct_types(self, type_required: bool = False) -> t.Optional[exp.Expression]:
    3835        index = self._index
    3836        this = self._parse_type(parse_interval=False) or self._parse_id_var()
    3837        self._match(TokenType.COLON)
    3838        column_def = self._parse_column_def(this)
    3839
    3840        if type_required and (
    3841            (isinstance(this, exp.Column) and this.this is column_def) or this is column_def
    3842        ):
    3843            self._retreat(index)
    3844            return self._parse_types()
    3845
    3846        return column_def
    3847
    3848    def _parse_at_time_zone(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    3849        if not self._match_text_seq("AT", "TIME", "ZONE"):
    3850            return this
    3851        return self.expression(exp.AtTimeZone, this=this, zone=self._parse_unary())
    3852
    3853    def _parse_column(self) -> t.Optional[exp.Expression]:
    3854        this = self._parse_field()
    3855        if isinstance(this, exp.Identifier):
    3856            this = self.expression(exp.Column, this=this)
    3857        elif not this:
    3858            return self._parse_bracket(this)
    3859        return self._parse_column_ops(this)
    3860
    3861    def _parse_column_ops(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    3862        this = self._parse_bracket(this)
    3863
    3864        while self._match_set(self.COLUMN_OPERATORS):
    3865            op_token = self._prev.token_type
    3866            op = self.COLUMN_OPERATORS.get(op_token)
    3867
    3868            if op_token == TokenType.DCOLON:
    3869                field = self._parse_types()
    3870                if not field:
    3871                    self.raise_error("Expected type")
    3872            elif op and self._curr:
    3873                self._advance()
    3874                value = self._prev.text
    3875                field = (
    3876                    exp.Literal.number(value)
    3877                    if self._prev.token_type == TokenType.NUMBER
    3878                    else exp.Literal.string(value)
    3879                )
    3880            else:
    3881                field = self._parse_field(anonymous_func=True, any_token=True)
    3882
    3883            if isinstance(field, exp.Func):
    3884                # bigquery allows function calls like x.y.count(...)
    3885                # SAFE.SUBSTR(...)
    3886                # https://cloud.google.com/bigquery/docs/reference/standard-sql/functions-reference#function_call_rules
    3887                this = self._replace_columns_with_dots(this)
    3888
    3889            if op:
    3890                this = op(self, this, field)
    3891            elif isinstance(this, exp.Column) and not this.args.get("catalog"):
    3892                this = self.expression(
    3893                    exp.Column,
    3894                    this=field,
    3895                    table=this.this,
    3896                    db=this.args.get("table"),
    3897                    catalog=this.args.get("db"),
    3898                )
    3899            else:
    3900                this = self.expression(exp.Dot, this=this, expression=field)
    3901            this = self._parse_bracket(this)
    3902        return this
    3903
    3904    def _parse_primary(self) -> t.Optional[exp.Expression]:
    3905        if self._match_set(self.PRIMARY_PARSERS):
    3906            token_type = self._prev.token_type
    3907            primary = self.PRIMARY_PARSERS[token_type](self, self._prev)
    3908
    3909            if token_type == TokenType.STRING:
    3910                expressions = [primary]
    3911                while self._match(TokenType.STRING):
    3912                    expressions.append(exp.Literal.string(self._prev.text))
    3913
    3914                if len(expressions) > 1:
    3915                    return self.expression(exp.Concat, expressions=expressions)
    3916
    3917            return primary
    3918
    3919        if self._match_pair(TokenType.DOT, TokenType.NUMBER):
    3920            return exp.Literal.number(f"0.{self._prev.text}")
    3921
    3922        if self._match(TokenType.L_PAREN):
    3923            comments = self._prev_comments
    3924            query = self._parse_select()
    3925
    3926            if query:
    3927                expressions = [query]
    3928            else:
    3929                expressions = self._parse_expressions()
    3930
    3931            this = self._parse_query_modifiers(seq_get(expressions, 0))
    3932
    3933            if isinstance(this, exp.Subqueryable):
    3934                this = self._parse_set_operations(
    3935                    self._parse_subquery(this=this, parse_alias=False)
    3936                )
    3937            elif len(expressions) > 1:
    3938                this = self.expression(exp.Tuple, expressions=expressions)
    3939            else:
    3940                this = self.expression(exp.Paren, this=self._parse_set_operations(this))
    3941
    3942            if this:
    3943                this.add_comments(comments)
    3944
    3945            self._match_r_paren(expression=this)
    3946            return this
    3947
    3948        return None
    3949
    3950    def _parse_field(
    3951        self,
    3952        any_token: bool = False,
    3953        tokens: t.Optional[t.Collection[TokenType]] = None,
    3954        anonymous_func: bool = False,
    3955    ) -> t.Optional[exp.Expression]:
    3956        return (
    3957            self._parse_primary()
    3958            or self._parse_function(anonymous=anonymous_func)
    3959            or self._parse_id_var(any_token=any_token, tokens=tokens)
    3960        )
    3961
    3962    def _parse_function(
    3963        self,
    3964        functions: t.Optional[t.Dict[str, t.Callable]] = None,
    3965        anonymous: bool = False,
    3966        optional_parens: bool = True,
    3967    ) -> t.Optional[exp.Expression]:
    3968        # This allows us to also parse {fn <function>} syntax (Snowflake, MySQL support this)
    3969        # See: https://community.snowflake.com/s/article/SQL-Escape-Sequences
    3970        fn_syntax = False
    3971        if (
    3972            self._match(TokenType.L_BRACE, advance=False)
    3973            and self._next
    3974            and self._next.text.upper() == "FN"
    3975        ):
    3976            self._advance(2)
    3977            fn_syntax = True
    3978
    3979        func = self._parse_function_call(
    3980            functions=functions, anonymous=anonymous, optional_parens=optional_parens
    3981        )
    3982
    3983        if fn_syntax:
    3984            self._match(TokenType.R_BRACE)
    3985
    3986        return func
    3987
    3988    def _parse_function_call(
    3989        self,
    3990        functions: t.Optional[t.Dict[str, t.Callable]] = None,
    3991        anonymous: bool = False,
    3992        optional_parens: bool = True,
    3993    ) -> t.Optional[exp.Expression]:
    3994        if not self._curr:
    3995            return None
    3996
    3997        comments = self._curr.comments
    3998        token_type = self._curr.token_type
    3999        this = self._curr.text
    4000        upper = this.upper()
    4001
    4002        parser = self.NO_PAREN_FUNCTION_PARSERS.get(upper)
    4003        if optional_parens and parser and token_type not in self.INVALID_FUNC_NAME_TOKENS:
    4004            self._advance()
    4005            return parser(self)
    4006
    4007        if not self._next or self._next.token_type != TokenType.L_PAREN:
    4008            if optional_parens and token_type in self.NO_PAREN_FUNCTIONS:
    4009                self._advance()
    4010                return self.expression(self.NO_PAREN_FUNCTIONS[token_type])
    4011
    4012            return None
    4013
    4014        if token_type not in self.FUNC_TOKENS:
    4015            return None
    4016
    4017        self._advance(2)
    4018
    4019        parser = self.FUNCTION_PARSERS.get(upper)
    4020        if parser and not anonymous:
    4021            this = parser(self)
    4022        else:
    4023            subquery_predicate = self.SUBQUERY_PREDICATES.get(token_type)
    4024
    4025            if subquery_predicate and self._curr.token_type in (TokenType.SELECT, TokenType.WITH):
    4026                this = self.expression(subquery_predicate, this=self._parse_select())
    4027                self._match_r_paren()
    4028                return this
    4029
    4030            if functions is None:
    4031                functions = self.FUNCTIONS
    4032
    4033            function = functions.get(upper)
    4034
    4035            alias = upper in self.FUNCTIONS_WITH_ALIASED_ARGS
    4036            args = self._parse_csv(lambda: self._parse_lambda(alias=alias))
    4037
    4038            if function and not anonymous:
    4039                if "dialect" in function.__code__.co_varnames:
    4040                    func = function(args, dialect=self.dialect)
    4041                else:
    4042                    func = function(args)
    4043
    4044                func = self.validate_expression(func, args)
    4045                if not self.dialect.NORMALIZE_FUNCTIONS:
    4046                    func.meta["name"] = this
    4047
    4048                this = func
    4049            else:
    4050                this = self.expression(exp.Anonymous, this=this, expressions=args)
    4051
    4052        if isinstance(this, exp.Expression):
    4053            this.add_comments(comments)
    4054
    4055        self._match_r_paren(this)
    4056        return self._parse_window(this)
    4057
    4058    def _parse_function_parameter(self) -> t.Optional[exp.Expression]:
    4059        return self._parse_column_def(self._parse_id_var())
    4060
    4061    def _parse_user_defined_function(
    4062        self, kind: t.Optional[TokenType] = None
    4063    ) -> t.Optional[exp.Expression]:
    4064        this = self._parse_id_var()
    4065
    4066        while self._match(TokenType.DOT):
    4067            this = self.expression(exp.Dot, this=this, expression=self._parse_id_var())
    4068
    4069        if not self._match(TokenType.L_PAREN):
    4070            return this
    4071
    4072        expressions = self._parse_csv(self._parse_function_parameter)
    4073        self._match_r_paren()
    4074        return self.expression(
    4075            exp.UserDefinedFunction, this=this, expressions=expressions, wrapped=True
    4076        )
    4077
    4078    def _parse_introducer(self, token: Token) -> exp.Introducer | exp.Identifier:
    4079        literal = self._parse_primary()
    4080        if literal:
    4081            return self.expression(exp.Introducer, this=token.text, expression=literal)
    4082
    4083        return self.expression(exp.Identifier, this=token.text)
    4084
    4085    def _parse_session_parameter(self) -> exp.SessionParameter:
    4086        kind = None
    4087        this = self._parse_id_var() or self._parse_primary()
    4088
    4089        if this and self._match(TokenType.DOT):
    4090            kind = this.name
    4091            this = self._parse_var() or self._parse_primary()
    4092
    4093        return self.expression(exp.SessionParameter, this=this, kind=kind)
    4094
    4095    def _parse_lambda(self, alias: bool = False) -> t.Optional[exp.Expression]:
    4096        index = self._index
    4097
    4098        if self._match(TokenType.L_PAREN):
    4099            expressions = t.cast(
    4100                t.List[t.Optional[exp.Expression]], self._parse_csv(self._parse_id_var)
    4101            )
    4102
    4103            if not self._match(TokenType.R_PAREN):
    4104                self._retreat(index)
    4105        else:
    4106            expressions = [self._parse_id_var()]
    4107
    4108        if self._match_set(self.LAMBDAS):
    4109            return self.LAMBDAS[self._prev.token_type](self, expressions)
    4110
    4111        self._retreat(index)
    4112
    4113        this: t.Optional[exp.Expression]
    4114
    4115        if self._match(TokenType.DISTINCT):
    4116            this = self.expression(
    4117                exp.Distinct, expressions=self._parse_csv(self._parse_conjunction)
    4118            )
    4119        else:
    4120            this = self._parse_select_or_expression(alias=alias)
    4121
    4122        return self._parse_limit(self._parse_order(self._parse_respect_or_ignore_nulls(this)))
    4123
    4124    def _parse_schema(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
    4125        index = self._index
    4126
    4127        if not self.errors:
    4128            try:
    4129                if self._parse_select(nested=True):
    4130                    return this
    4131            except ParseError:
    4132                pass
    4133            finally:
    4134                self.errors.clear()
    4135                self._retreat(index)
    4136
    4137        if not self._match(TokenType.L_PAREN):
    4138            return this
    4139
    4140        args = self._parse_csv(lambda: self._parse_constraint() or self._parse_field_def())
    4141
    4142        self._match_r_paren()
    4143        return self.expression(exp.Schema, this=this, expressions=args)
    4144
    4145    def _parse_field_def(self) -> t.Optional[exp.Expression]:
    4146        return self._parse_column_def(self._parse_field(any_token=True))
    4147
    4148    def _parse_column_def(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    4149        # column defs are not really columns, they're identifiers
    4150        if isinstance(this, exp.Column):
    4151            this = this.this
    4152
    4153        kind = self._parse_types(schema=True)
    4154
    4155        if self._match_text_seq("FOR", "ORDINALITY"):
    4156            return self.expression(exp.ColumnDef, this=this, ordinality=True)
    4157
    4158        constraints: t.List[exp.Expression] = []
    4159
    4160        if not kind and self._match(TokenType.ALIAS):
    4161            constraints.append(
    4162                self.expression(
    4163                    exp.ComputedColumnConstraint,
    4164                    this=self._parse_conjunction(),
    4165                    persisted=self._match_text_seq("PERSISTED"),
    4166                    not_null=self._match_pair(TokenType.NOT, TokenType.NULL),
    4167                )
    4168            )
    4169        elif kind and self._match_pair(TokenType.ALIAS, TokenType.L_PAREN, advance=False):
    4170            self._match(TokenType.ALIAS)
    4171            constraints.append(
    4172                self.expression(exp.TransformColumnConstraint, this=self._parse_field())
    4173            )
    4174
    4175        while True:
    4176            constraint = self._parse_column_constraint()
    4177            if not constraint:
    4178                break
    4179            constraints.append(constraint)
    4180
    4181        if not kind and not constraints:
    4182            return this
    4183
    4184        return self.expression(exp.ColumnDef, this=this, kind=kind, constraints=constraints)
    4185
    4186    def _parse_auto_increment(
    4187        self,
    4188    ) -> exp.GeneratedAsIdentityColumnConstraint | exp.AutoIncrementColumnConstraint:
    4189        start = None
    4190        increment = None
    4191
    4192        if self._match(TokenType.L_PAREN, advance=False):
    4193            args = self._parse_wrapped_csv(self._parse_bitwise)
    4194            start = seq_get(args, 0)
    4195            increment = seq_get(args, 1)
    4196        elif self._match_text_seq("START"):
    4197            start = self._parse_bitwise()
    4198            self._match_text_seq("INCREMENT")
    4199            increment = self._parse_bitwise()
    4200
    4201        if start and increment:
    4202            return exp.GeneratedAsIdentityColumnConstraint(start=start, increment=increment)
    4203
    4204        return exp.AutoIncrementColumnConstraint()
    4205
    4206    def _parse_auto_property(self) -> t.Optional[exp.AutoRefreshProperty]:
    4207        if not self._match_text_seq("REFRESH"):
    4208            self._retreat(self._index - 1)
    4209            return None
    4210        return self.expression(exp.AutoRefreshProperty, this=self._parse_var(upper=True))
    4211
    4212    def _parse_compress(self) -> exp.CompressColumnConstraint:
    4213        if self._match(TokenType.L_PAREN, advance=False):
    4214            return self.expression(
    4215                exp.CompressColumnConstraint, this=self._parse_wrapped_csv(self._parse_bitwise)
    4216            )
    4217
    4218        return self.expression(exp.CompressColumnConstraint, this=self._parse_bitwise())
    4219
    4220    def _parse_generated_as_identity(
    4221        self,
    4222    ) -> (
    4223        exp.GeneratedAsIdentityColumnConstraint
    4224        | exp.ComputedColumnConstraint
    4225        | exp.GeneratedAsRowColumnConstraint
    4226    ):
    4227        if self._match_text_seq("BY", "DEFAULT"):
    4228            on_null = self._match_pair(TokenType.ON, TokenType.NULL)
    4229            this = self.expression(
    4230                exp.GeneratedAsIdentityColumnConstraint, this=False, on_null=on_null
    4231            )
    4232        else:
    4233            self._match_text_seq("ALWAYS")
    4234            this = self.expression(exp.GeneratedAsIdentityColumnConstraint, this=True)
    4235
    4236        self._match(TokenType.ALIAS)
    4237
    4238        if self._match_text_seq("ROW"):
    4239            start = self._match_text_seq("START")
    4240            if not start:
    4241                self._match(TokenType.END)
    4242            hidden = self._match_text_seq("HIDDEN")
    4243            return self.expression(exp.GeneratedAsRowColumnConstraint, start=start, hidden=hidden)
    4244
    4245        identity = self._match_text_seq("IDENTITY")
    4246
    4247        if self._match(TokenType.L_PAREN):
    4248            if self._match(TokenType.START_WITH):
    4249                this.set("start", self._parse_bitwise())
    4250            if self._match_text_seq("INCREMENT", "BY"):
    4251                this.set("increment", self._parse_bitwise())
    4252            if self._match_text_seq("MINVALUE"):
    4253                this.set("minvalue", self._parse_bitwise())
    4254            if self._match_text_seq("MAXVALUE"):
    4255                this.set("maxvalue", self._parse_bitwise())
    4256
    4257            if self._match_text_seq("CYCLE"):
    4258                this.set("cycle", True)
    4259            elif self._match_text_seq("NO", "CYCLE"):
    4260                this.set("cycle", False)
    4261
    4262            if not identity:
    4263                this.set("expression", self._parse_bitwise())
    4264            elif not this.args.get("start") and self._match(TokenType.NUMBER, advance=False):
    4265                args = self._parse_csv(self._parse_bitwise)
    4266                this.set("start", seq_get(args, 0))
    4267                this.set("increment", seq_get(args, 1))
    4268
    4269            self._match_r_paren()
    4270
    4271        return this
    4272
    4273    def _parse_inline(self) -> exp.InlineLengthColumnConstraint:
    4274        self._match_text_seq("LENGTH")
    4275        return self.expression(exp.InlineLengthColumnConstraint, this=self._parse_bitwise())
    4276
    4277    def _parse_not_constraint(
    4278        self,
    4279    ) -> t.Optional[exp.Expression]:
    4280        if self._match_text_seq("NULL"):
    4281            return self.expression(exp.NotNullColumnConstraint)
    4282        if self._match_text_seq("CASESPECIFIC"):
    4283            return self.expression(exp.CaseSpecificColumnConstraint, not_=True)
    4284        if self._match_text_seq("FOR", "REPLICATION"):
    4285            return self.expression(exp.NotForReplicationColumnConstraint)
    4286        return None
    4287
    4288    def _parse_column_constraint(self) -> t.Optional[exp.Expression]:
    4289        if self._match(TokenType.CONSTRAINT):
    4290            this = self._parse_id_var()
    4291        else:
    4292            this = None
    4293
    4294        if self._match_texts(self.CONSTRAINT_PARSERS):
    4295            return self.expression(
    4296                exp.ColumnConstraint,
    4297                this=this,
    4298                kind=self.CONSTRAINT_PARSERS[self._prev.text.upper()](self),
    4299            )
    4300
    4301        return this
    4302
    4303    def _parse_constraint(self) -> t.Optional[exp.Expression]:
    4304        if not self._match(TokenType.CONSTRAINT):
    4305            return self._parse_unnamed_constraint(constraints=self.SCHEMA_UNNAMED_CONSTRAINTS)
    4306
    4307        this = self._parse_id_var()
    4308        expressions = []
    4309
    4310        while True:
    4311            constraint = self._parse_unnamed_constraint() or self._parse_function()
    4312            if not constraint:
    4313                break
    4314            expressions.append(constraint)
    4315
    4316        return self.expression(exp.Constraint, this=this, expressions=expressions)
    4317
    4318    def _parse_unnamed_constraint(
    4319        self, constraints: t.Optional[t.Collection[str]] = None
    4320    ) -> t.Optional[exp.Expression]:
    4321        if self._match(TokenType.IDENTIFIER, advance=False) or not self._match_texts(
    4322            constraints or self.CONSTRAINT_PARSERS
    4323        ):
    4324            return None
    4325
    4326        constraint = self._prev.text.upper()
    4327        if constraint not in self.CONSTRAINT_PARSERS:
    4328            self.raise_error(f"No parser found for schema constraint {constraint}.")
    4329
    4330        return self.CONSTRAINT_PARSERS[constraint](self)
    4331
    4332    def _parse_unique(self) -> exp.UniqueColumnConstraint:
    4333        self._match_text_seq("KEY")
    4334        return self.expression(
    4335            exp.UniqueColumnConstraint,
    4336            this=self._parse_schema(self._parse_id_var(any_token=False)),
    4337            index_type=self._match(TokenType.USING) and self._advance_any() and self._prev.text,
    4338        )
    4339
    4340    def _parse_key_constraint_options(self) -> t.List[str]:
    4341        options = []
    4342        while True:
    4343            if not self._curr:
    4344                break
    4345
    4346            if self._match(TokenType.ON):
    4347                action = None
    4348                on = self._advance_any() and self._prev.text
    4349
    4350                if self._match_text_seq("NO", "ACTION"):
    4351                    action = "NO ACTION"
    4352                elif self._match_text_seq("CASCADE"):
    4353                    action = "CASCADE"
    4354                elif self._match_text_seq("RESTRICT"):
    4355                    action = "RESTRICT"
    4356                elif self._match_pair(TokenType.SET, TokenType.NULL):
    4357                    action = "SET NULL"
    4358                elif self._match_pair(TokenType.SET, TokenType.DEFAULT):
    4359                    action = "SET DEFAULT"
    4360                else:
    4361                    self.raise_error("Invalid key constraint")
    4362
    4363                options.append(f"ON {on} {action}")
    4364            elif self._match_text_seq("NOT", "ENFORCED"):
    4365                options.append("NOT ENFORCED")
    4366            elif self._match_text_seq("DEFERRABLE"):
    4367                options.append("DEFERRABLE")
    4368            elif self._match_text_seq("INITIALLY", "DEFERRED"):
    4369                options.append("INITIALLY DEFERRED")
    4370            elif self._match_text_seq("NORELY"):
    4371                options.append("NORELY")
    4372            elif self._match_text_seq("MATCH", "FULL"):
    4373                options.append("MATCH FULL")
    4374            else:
    4375                break
    4376
    4377        return options
    4378
    4379    def _parse_references(self, match: bool = True) -> t.Optional[exp.Reference]:
    4380        if match and not self._match(TokenType.REFERENCES):
    4381            return None
    4382
    4383        expressions = None
    4384        this = self._parse_table(schema=True)
    4385        options = self._parse_key_constraint_options()
    4386        return self.expression(exp.Reference, this=this, expressions=expressions, options=options)
    4387
    4388    def _parse_foreign_key(self) -> exp.ForeignKey:
    4389        expressions = self._parse_wrapped_id_vars()
    4390        reference = self._parse_references()
    4391        options = {}
    4392
    4393        while self._match(TokenType.ON):
    4394            if not self._match_set((TokenType.DELETE, TokenType.UPDATE)):
    4395                self.raise_error("Expected DELETE or UPDATE")
    4396
    4397            kind = self._prev.text.lower()
    4398
    4399            if self._match_text_seq("NO", "ACTION"):
    4400                action = "NO ACTION"
    4401            elif self._match(TokenType.SET):
    4402                self._match_set((TokenType.NULL, TokenType.DEFAULT))
    4403                action = "SET " + self._prev.text.upper()
    4404            else:
    4405                self._advance()
    4406                action = self._prev.text.upper()
    4407
    4408            options[kind] = action
    4409
    4410        return self.expression(
    4411            exp.ForeignKey,
    4412            expressions=expressions,
    4413            reference=reference,
    4414            **options,  # type: ignore
    4415        )
    4416
    4417    def _parse_primary_key_part(self) -> t.Optional[exp.Expression]:
    4418        return self._parse_field()
    4419
    4420    def _parse_period_for_system_time(self) -> t.Optional[exp.PeriodForSystemTimeConstraint]:
    4421        if not self._match(TokenType.TIMESTAMP_SNAPSHOT):
    4422            self._retreat(self._index - 1)
    4423            return None
    4424
    4425        id_vars = self._parse_wrapped_id_vars()
    4426        return self.expression(
    4427            exp.PeriodForSystemTimeConstraint,
    4428            this=seq_get(id_vars, 0),
    4429            expression=seq_get(id_vars, 1),
    4430        )
    4431
    4432    def _parse_primary_key(
    4433        self, wrapped_optional: bool = False, in_props: bool = False
    4434    ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
    4435        desc = (
    4436            self._match_set((TokenType.ASC, TokenType.DESC))
    4437            and self._prev.token_type == TokenType.DESC
    4438        )
    4439
    4440        if not in_props and not self._match(TokenType.L_PAREN, advance=False):
    4441            return self.expression(exp.PrimaryKeyColumnConstraint, desc=desc)
    4442
    4443        expressions = self._parse_wrapped_csv(
    4444            self._parse_primary_key_part, optional=wrapped_optional
    4445        )
    4446        options = self._parse_key_constraint_options()
    4447        return self.expression(exp.PrimaryKey, expressions=expressions, options=options)
    4448
    4449    def _parse_bracket_key_value(self, is_map: bool = False) -> t.Optional[exp.Expression]:
    4450        return self._parse_slice(self._parse_alias(self._parse_conjunction(), explicit=True))
    4451
    4452    def _parse_bracket(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    4453        if not self._match_set((TokenType.L_BRACKET, TokenType.L_BRACE)):
    4454            return this
    4455
    4456        bracket_kind = self._prev.token_type
    4457        expressions = self._parse_csv(
    4458            lambda: self._parse_bracket_key_value(is_map=bracket_kind == TokenType.L_BRACE)
    4459        )
    4460
    4461        if not self._match(TokenType.R_BRACKET) and bracket_kind == TokenType.L_BRACKET:
    4462            self.raise_error("Expected ]")
    4463        elif not self._match(TokenType.R_BRACE) and bracket_kind == TokenType.L_BRACE:
    4464            self.raise_error("Expected }")
    4465
    4466        # https://duckdb.org/docs/sql/data_types/struct.html#creating-structs
    4467        if bracket_kind == TokenType.L_BRACE:
    4468            this = self.expression(exp.Struct, expressions=expressions)
    4469        elif not this or this.name.upper() == "ARRAY":
    4470            this = self.expression(exp.Array, expressions=expressions)
    4471        else:
    4472            expressions = apply_index_offset(this, expressions, -self.dialect.INDEX_OFFSET)
    4473            this = self.expression(exp.Bracket, this=this, expressions=expressions)
    4474
    4475        self._add_comments(this)
    4476        return self._parse_bracket(this)
    4477
    4478    def _parse_slice(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    4479        if self._match(TokenType.COLON):
    4480            return self.expression(exp.Slice, this=this, expression=self._parse_conjunction())
    4481        return this
    4482
    4483    def _parse_case(self) -> t.Optional[exp.Expression]:
    4484        ifs = []
    4485        default = None
    4486
    4487        comments = self._prev_comments
    4488        expression = self._parse_conjunction()
    4489
    4490        while self._match(TokenType.WHEN):
    4491            this = self._parse_conjunction()
    4492            self._match(TokenType.THEN)
    4493            then = self._parse_conjunction()
    4494            ifs.append(self.expression(exp.If, this=this, true=then))
    4495
    4496        if self._match(TokenType.ELSE):
    4497            default = self._parse_conjunction()
    4498
    4499        if not self._match(TokenType.END):
    4500            if isinstance(default, exp.Interval) and default.this.sql().upper() == "END":
    4501                default = exp.column("interval")
    4502            else:
    4503                self.raise_error("Expected END after CASE", self._prev)
    4504
    4505        return self._parse_window(
    4506            self.expression(exp.Case, comments=comments, this=expression, ifs=ifs, default=default)
    4507        )
    4508
    4509    def _parse_if(self) -> t.Optional[exp.Expression]:
    4510        if self._match(TokenType.L_PAREN):
    4511            args = self._parse_csv(self._parse_conjunction)
    4512            this = self.validate_expression(exp.If.from_arg_list(args), args)
    4513            self._match_r_paren()
    4514        else:
    4515            index = self._index - 1
    4516
    4517            if self.NO_PAREN_IF_COMMANDS and index == 0:
    4518                return self._parse_as_command(self._prev)
    4519
    4520            condition = self._parse_conjunction()
    4521
    4522            if not condition:
    4523                self._retreat(index)
    4524                return None
    4525
    4526            self._match(TokenType.THEN)
    4527            true = self._parse_conjunction()
    4528            false = self._parse_conjunction() if self._match(TokenType.ELSE) else None
    4529            self._match(TokenType.END)
    4530            this = self.expression(exp.If, this=condition, true=true, false=false)
    4531
    4532        return self._parse_window(this)
    4533
    4534    def _parse_next_value_for(self) -> t.Optional[exp.Expression]:
    4535        if not self._match_text_seq("VALUE", "FOR"):
    4536            self._retreat(self._index - 1)
    4537            return None
    4538
    4539        return self.expression(
    4540            exp.NextValueFor,
    4541            this=self._parse_column(),
    4542            order=self._match(TokenType.OVER) and self._parse_wrapped(self._parse_order),
    4543        )
    4544
    4545    def _parse_extract(self) -> exp.Extract:
    4546        this = self._parse_function() or self._parse_var() or self._parse_type()
    4547
    4548        if self._match(TokenType.FROM):
    4549            return self.expression(exp.Extract, this=this, expression=self._parse_bitwise())
    4550
    4551        if not self._match(TokenType.COMMA):
    4552            self.raise_error("Expected FROM or comma after EXTRACT", self._prev)
    4553
    4554        return self.expression(exp.Extract, this=this, expression=self._parse_bitwise())
    4555
    4556    def _parse_any_value(self) -> exp.AnyValue:
    4557        this = self._parse_lambda()
    4558        is_max = None
    4559        having = None
    4560
    4561        if self._match(TokenType.HAVING):
    4562            self._match_texts(("MAX", "MIN"))
    4563            is_max = self._prev.text == "MAX"
    4564            having = self._parse_column()
    4565
    4566        return self.expression(exp.AnyValue, this=this, having=having, max=is_max)
    4567
    4568    def _parse_cast(self, strict: bool, safe: t.Optional[bool] = None) -> exp.Expression:
    4569        this = self._parse_conjunction()
    4570
    4571        if not self._match(TokenType.ALIAS):
    4572            if self._match(TokenType.COMMA):
    4573                return self.expression(exp.CastToStrType, this=this, to=self._parse_string())
    4574
    4575            self.raise_error("Expected AS after CAST")
    4576
    4577        fmt = None
    4578        to = self._parse_types()
    4579
    4580        if self._match(TokenType.FORMAT):
    4581            fmt_string = self._parse_string()
    4582            fmt = self._parse_at_time_zone(fmt_string)
    4583
    4584            if not to:
    4585                to = exp.DataType.build(exp.DataType.Type.UNKNOWN)
    4586            if to.this in exp.DataType.TEMPORAL_TYPES:
    4587                this = self.expression(
    4588                    exp.StrToDate if to.this == exp.DataType.Type.DATE else exp.StrToTime,
    4589                    this=this,
    4590                    format=exp.Literal.string(
    4591                        format_time(
    4592                            fmt_string.this if fmt_string else "",
    4593                            self.dialect.FORMAT_MAPPING or self.dialect.TIME_MAPPING,
    4594                            self.dialect.FORMAT_TRIE or self.dialect.TIME_TRIE,
    4595                        )
    4596                    ),
    4597                )
    4598
    4599                if isinstance(fmt, exp.AtTimeZone) and isinstance(this, exp.StrToTime):
    4600                    this.set("zone", fmt.args["zone"])
    4601                return this
    4602        elif not to:
    4603            self.raise_error("Expected TYPE after CAST")
    4604        elif isinstance(to, exp.Identifier):
    4605            to = exp.DataType.build(to.name, udt=True)
    4606        elif to.this == exp.DataType.Type.CHAR:
    4607            if self._match(TokenType.CHARACTER_SET):
    4608                to = self.expression(exp.CharacterSet, this=self._parse_var_or_string())
    4609
    4610        return self.expression(
    4611            exp.Cast if strict else exp.TryCast, this=this, to=to, format=fmt, safe=safe
    4612        )
    4613
    4614    def _parse_string_agg(self) -> exp.Expression:
    4615        if self._match(TokenType.DISTINCT):
    4616            args: t.List[t.Optional[exp.Expression]] = [
    4617                self.expression(exp.Distinct, expressions=[self._parse_conjunction()])
    4618            ]
    4619            if self._match(TokenType.COMMA):
    4620                args.extend(self._parse_csv(self._parse_conjunction))
    4621        else:
    4622            args = self._parse_csv(self._parse_conjunction)  # type: ignore
    4623
    4624        index = self._index
    4625        if not self._match(TokenType.R_PAREN) and args:
    4626            # postgres: STRING_AGG([DISTINCT] expression, separator [ORDER BY expression1 {ASC | DESC} [, ...]])
    4627            # bigquery: STRING_AGG([DISTINCT] expression [, separator] [ORDER BY key [{ASC | DESC}] [, ... ]] [LIMIT n])
    4628            args[-1] = self._parse_limit(this=self._parse_order(this=args[-1]))
    4629            return self.expression(exp.GroupConcat, this=args[0], separator=seq_get(args, 1))
    4630
    4631        # Checks if we can parse an order clause: WITHIN GROUP (ORDER BY <order_by_expression_list> [ASC | DESC]).
    4632        # This is done "manually", instead of letting _parse_window parse it into an exp.WithinGroup node, so that
    4633        # the STRING_AGG call is parsed like in MySQL / SQLite and can thus be transpiled more easily to them.
    4634        if not self._match_text_seq("WITHIN", "GROUP"):
    4635            self._retreat(index)
    4636            return self.validate_expression(exp.GroupConcat.from_arg_list(args), args)
    4637
    4638        self._match_l_paren()  # The corresponding match_r_paren will be called in parse_function (caller)
    4639        order = self._parse_order(this=seq_get(args, 0))
    4640        return self.expression(exp.GroupConcat, this=order, separator=seq_get(args, 1))
    4641
    4642    def _parse_convert(
    4643        self, strict: bool, safe: t.Optional[bool] = None
    4644    ) -> t.Optional[exp.Expression]:
    4645        this = self._parse_bitwise()
    4646
    4647        if self._match(TokenType.USING):
    4648            to: t.Optional[exp.Expression] = self.expression(
    4649                exp.CharacterSet, this=self._parse_var()
    4650            )
    4651        elif self._match(TokenType.COMMA):
    4652            to = self._parse_types()
    4653        else:
    4654            to = None
    4655
    4656        return self.expression(exp.Cast if strict else exp.TryCast, this=this, to=to, safe=safe)
    4657
    4658    def _parse_decode(self) -> t.Optional[exp.Decode | exp.Case]:
    4659        """
    4660        There are generally two variants of the DECODE function:
    4661
    4662        - DECODE(bin, charset)
    4663        - DECODE(expression, search, result [, search, result] ... [, default])
    4664
    4665        The second variant will always be parsed into a CASE expression. Note that NULL
    4666        needs special treatment, since we need to explicitly check for it with `IS NULL`,
    4667        instead of relying on pattern matching.
    4668        """
    4669        args = self._parse_csv(self._parse_conjunction)
    4670
    4671        if len(args) < 3:
    4672            return self.expression(exp.Decode, this=seq_get(args, 0), charset=seq_get(args, 1))
    4673
    4674        expression, *expressions = args
    4675        if not expression:
    4676            return None
    4677
    4678        ifs = []
    4679        for search, result in zip(expressions[::2], expressions[1::2]):
    4680            if not search or not result:
    4681                return None
    4682
    4683            if isinstance(search, exp.Literal):
    4684                ifs.append(
    4685                    exp.If(this=exp.EQ(this=expression.copy(), expression=search), true=result)
    4686                )
    4687            elif isinstance(search, exp.Null):
    4688                ifs.append(
    4689                    exp.If(this=exp.Is(this=expression.copy(), expression=exp.Null()), true=result)
    4690                )
    4691            else:
    4692                cond = exp.or_(
    4693                    exp.EQ(this=expression.copy(), expression=search),
    4694                    exp.and_(
    4695                        exp.Is(this=expression.copy(), expression=exp.Null()),
    4696                        exp.Is(this=search.copy(), expression=exp.Null()),
    4697                        copy=False,
    4698                    ),
    4699                    copy=False,
    4700                )
    4701                ifs.append(exp.If(this=cond, true=result))
    4702
    4703        return exp.Case(ifs=ifs, default=expressions[-1] if len(expressions) % 2 == 1 else None)
    4704
    4705    def _parse_json_key_value(self) -> t.Optional[exp.JSONKeyValue]:
    4706        self._match_text_seq("KEY")
    4707        key = self._parse_column()
    4708        self._match_set(self.JSON_KEY_VALUE_SEPARATOR_TOKENS)
    4709        self._match_text_seq("VALUE")
    4710        value = self._parse_bitwise()
    4711
    4712        if not key and not value:
    4713            return None
    4714        return self.expression(exp.JSONKeyValue, this=key, expression=value)
    4715
    4716    def _parse_format_json(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    4717        if not this or not self._match_text_seq("FORMAT", "JSON"):
    4718            return this
    4719
    4720        return self.expression(exp.FormatJson, this=this)
    4721
    4722    def _parse_on_handling(self, on: str, *values: str) -> t.Optional[str]:
    4723        # Parses the "X ON Y" syntax, i.e. NULL ON NULL (Oracle, T-SQL)
    4724        for value in values:
    4725            if self._match_text_seq(value, "ON", on):
    4726                return f"{value} ON {on}"
    4727
    4728        return None
    4729
    4730    @t.overload
    4731    def _parse_json_object(self, agg: Lit[False]) -> exp.JSONObject:
    4732        ...
    4733
    4734    @t.overload
    4735    def _parse_json_object(self, agg: Lit[True]) -> exp.JSONObjectAgg:
    4736        ...
    4737
    4738    def _parse_json_object(self, agg=False):
    4739        star = self._parse_star()
    4740        expressions = (
    4741            [star]
    4742            if star
    4743            else self._parse_csv(lambda: self._parse_format_json(self._parse_json_key_value()))
    4744        )
    4745        null_handling = self._parse_on_handling("NULL", "NULL", "ABSENT")
    4746
    4747        unique_keys = None
    4748        if self._match_text_seq("WITH", "UNIQUE"):
    4749            unique_keys = True
    4750        elif self._match_text_seq("WITHOUT", "UNIQUE"):
    4751            unique_keys = False
    4752
    4753        self._match_text_seq("KEYS")
    4754
    4755        return_type = self._match_text_seq("RETURNING") and self._parse_format_json(
    4756            self._parse_type()
    4757        )
    4758        encoding = self._match_text_seq("ENCODING") and self._parse_var()
    4759
    4760        return self.expression(
    4761            exp.JSONObjectAgg if agg else exp.JSONObject,
    4762            expressions=expressions,
    4763            null_handling=null_handling,
    4764            unique_keys=unique_keys,
    4765            return_type=return_type,
    4766            encoding=encoding,
    4767        )
    4768
    4769    # Note: this is currently incomplete; it only implements the "JSON_value_column" part
    4770    def _parse_json_column_def(self) -> exp.JSONColumnDef:
    4771        if not self._match_text_seq("NESTED"):
    4772            this = self._parse_id_var()
    4773            kind = self._parse_types(allow_identifiers=False)
    4774            nested = None
    4775        else:
    4776            this = None
    4777            kind = None
    4778            nested = True
    4779
    4780        path = self._match_text_seq("PATH") and self._parse_string()
    4781        nested_schema = nested and self._parse_json_schema()
    4782
    4783        return self.expression(
    4784            exp.JSONColumnDef,
    4785            this=this,
    4786            kind=kind,
    4787            path=path,
    4788            nested_schema=nested_schema,
    4789        )
    4790
    4791    def _parse_json_schema(self) -> exp.JSONSchema:
    4792        self._match_text_seq("COLUMNS")
    4793        return self.expression(
    4794            exp.JSONSchema,
    4795            expressions=self._parse_wrapped_csv(self._parse_json_column_def, optional=True),
    4796        )
    4797
    4798    def _parse_json_table(self) -> exp.JSONTable:
    4799        this = self._parse_format_json(self._parse_bitwise())
    4800        path = self._match(TokenType.COMMA) and self._parse_string()
    4801        error_handling = self._parse_on_handling("ERROR", "ERROR", "NULL")
    4802        empty_handling = self._parse_on_handling("EMPTY", "ERROR", "NULL")
    4803        schema = self._parse_json_schema()
    4804
    4805        return exp.JSONTable(
    4806            this=this,
    4807            schema=schema,
    4808            path=path,
    4809            error_handling=error_handling,
    4810            empty_handling=empty_handling,
    4811        )
    4812
    4813    def _parse_match_against(self) -> exp.MatchAgainst:
    4814        expressions = self._parse_csv(self._parse_column)
    4815
    4816        self._match_text_seq(")", "AGAINST", "(")
    4817
    4818        this = self._parse_string()
    4819
    4820        if self._match_text_seq("IN", "NATURAL", "LANGUAGE", "MODE"):
    4821            modifier = "IN NATURAL LANGUAGE MODE"
    4822            if self._match_text_seq("WITH", "QUERY", "EXPANSION"):
    4823                modifier = f"{modifier} WITH QUERY EXPANSION"
    4824        elif self._match_text_seq("IN", "BOOLEAN", "MODE"):
    4825            modifier = "IN BOOLEAN MODE"
    4826        elif self._match_text_seq("WITH", "QUERY", "EXPANSION"):
    4827            modifier = "WITH QUERY EXPANSION"
    4828        else:
    4829            modifier = None
    4830
    4831        return self.expression(
    4832            exp.MatchAgainst, this=this, expressions=expressions, modifier=modifier
    4833        )
    4834
    4835    # https://learn.microsoft.com/en-us/sql/t-sql/functions/openjson-transact-sql?view=sql-server-ver16
    4836    def _parse_open_json(self) -> exp.OpenJSON:
    4837        this = self._parse_bitwise()
    4838        path = self._match(TokenType.COMMA) and self._parse_string()
    4839
    4840        def _parse_open_json_column_def() -> exp.OpenJSONColumnDef:
    4841            this = self._parse_field(any_token=True)
    4842            kind = self._parse_types()
    4843            path = self._parse_string()
    4844            as_json = self._match_pair(TokenType.ALIAS, TokenType.JSON)
    4845
    4846            return self.expression(
    4847                exp.OpenJSONColumnDef, this=this, kind=kind, path=path, as_json=as_json
    4848            )
    4849
    4850        expressions = None
    4851        if self._match_pair(TokenType.R_PAREN, TokenType.WITH):
    4852            self._match_l_paren()
    4853            expressions = self._parse_csv(_parse_open_json_column_def)
    4854
    4855        return self.expression(exp.OpenJSON, this=this, path=path, expressions=expressions)
    4856
    4857    def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
    4858        args = self._parse_csv(self._parse_bitwise)
    4859
    4860        if self._match(TokenType.IN):
    4861            return self.expression(
    4862                exp.StrPosition, this=self._parse_bitwise(), substr=seq_get(args, 0)
    4863            )
    4864
    4865        if haystack_first:
    4866            haystack = seq_get(args, 0)
    4867            needle = seq_get(args, 1)
    4868        else:
    4869            needle = seq_get(args, 0)
    4870            haystack = seq_get(args, 1)
    4871
    4872        return self.expression(
    4873            exp.StrPosition, this=haystack, substr=needle, position=seq_get(args, 2)
    4874        )
    4875
    4876    def _parse_predict(self) -> exp.Predict:
    4877        self._match_text_seq("MODEL")
    4878        this = self._parse_table()
    4879
    4880        self._match(TokenType.COMMA)
    4881        self._match_text_seq("TABLE")
    4882
    4883        return self.expression(
    4884            exp.Predict,
    4885            this=this,
    4886            expression=self._parse_table(),
    4887            params_struct=self._match(TokenType.COMMA) and self._parse_bitwise(),
    4888        )
    4889
    4890    def _parse_join_hint(self, func_name: str) -> exp.JoinHint:
    4891        args = self._parse_csv(self._parse_table)
    4892        return exp.JoinHint(this=func_name.upper(), expressions=args)
    4893
    4894    def _parse_substring(self) -> exp.Substring:
    4895        # Postgres supports the form: substring(string [from int] [for int])
    4896        # https://www.postgresql.org/docs/9.1/functions-string.html @ Table 9-6
    4897
    4898        args = t.cast(t.List[t.Optional[exp.Expression]], self._parse_csv(self._parse_bitwise))
    4899
    4900        if self._match(TokenType.FROM):
    4901            args.append(self._parse_bitwise())
    4902            if self._match(TokenType.FOR):
    4903                args.append(self._parse_bitwise())
    4904
    4905        return self.validate_expression(exp.Substring.from_arg_list(args), args)
    4906
    4907    def _parse_trim(self) -> exp.Trim:
    4908        # https://www.w3resource.com/sql/character-functions/trim.php
    4909        # https://docs.oracle.com/javadb/10.8.3.0/ref/rreftrimfunc.html
    4910
    4911        position = None
    4912        collation = None
    4913        expression = None
    4914
    4915        if self._match_texts(self.TRIM_TYPES):
    4916            position = self._prev.text.upper()
    4917
    4918        this = self._parse_bitwise()
    4919        if self._match_set((TokenType.FROM, TokenType.COMMA)):
    4920            invert_order = self._prev.token_type == TokenType.FROM or self.TRIM_PATTERN_FIRST
    4921            expression = self._parse_bitwise()
    4922
    4923            if invert_order:
    4924                this, expression = expression, this
    4925
    4926        if self._match(TokenType.COLLATE):
    4927            collation = self._parse_bitwise()
    4928
    4929        return self.expression(
    4930            exp.Trim, this=this, position=position, expression=expression, collation=collation
    4931        )
    4932
    4933    def _parse_window_clause(self) -> t.Optional[t.List[exp.Expression]]:
    4934        return self._match(TokenType.WINDOW) and self._parse_csv(self._parse_named_window)
    4935
    4936    def _parse_named_window(self) -> t.Optional[exp.Expression]:
    4937        return self._parse_window(self._parse_id_var(), alias=True)
    4938
    4939    def _parse_respect_or_ignore_nulls(
    4940        self, this: t.Optional[exp.Expression]
    4941    ) -> t.Optional[exp.Expression]:
    4942        if self._match_text_seq("IGNORE", "NULLS"):
    4943            return self.expression(exp.IgnoreNulls, this=this)
    4944        if self._match_text_seq("RESPECT", "NULLS"):
    4945            return self.expression(exp.RespectNulls, this=this)
    4946        return this
    4947
    4948    def _parse_window(
    4949        self, this: t.Optional[exp.Expression], alias: bool = False
    4950    ) -> t.Optional[exp.Expression]:
    4951        if self._match_pair(TokenType.FILTER, TokenType.L_PAREN):
    4952            self._match(TokenType.WHERE)
    4953            this = self.expression(
    4954                exp.Filter, this=this, expression=self._parse_where(skip_where_token=True)
    4955            )
    4956            self._match_r_paren()
    4957
    4958        # T-SQL allows the OVER (...) syntax after WITHIN GROUP.
    4959        # https://learn.microsoft.com/en-us/sql/t-sql/functions/percentile-disc-transact-sql?view=sql-server-ver16
    4960        if self._match_text_seq("WITHIN", "GROUP"):
    4961            order = self._parse_wrapped(self._parse_order)
    4962            this = self.expression(exp.WithinGroup, this=this, expression=order)
    4963
    4964        # SQL spec defines an optional [ { IGNORE | RESPECT } NULLS ] OVER
    4965        # Some dialects choose to implement and some do not.
    4966        # https://dev.mysql.com/doc/refman/8.0/en/window-function-descriptions.html
    4967
    4968        # There is some code above in _parse_lambda that handles
    4969        #   SELECT FIRST_VALUE(TABLE.COLUMN IGNORE|RESPECT NULLS) OVER ...
    4970
    4971        # The below changes handle
    4972        #   SELECT FIRST_VALUE(TABLE.COLUMN) IGNORE|RESPECT NULLS OVER ...
    4973
    4974        # Oracle allows both formats
    4975        #   (https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/img_text/first_value.html)
    4976        #   and Snowflake chose to do the same for familiarity
    4977        #   https://docs.snowflake.com/en/sql-reference/functions/first_value.html#usage-notes
    4978        if isinstance(this, exp.AggFunc):
    4979            ignore_respect = this.find(exp.IgnoreNulls, exp.RespectNulls)
    4980
    4981            if ignore_respect and ignore_respect is not this:
    4982                ignore_respect.replace(ignore_respect.this)
    4983                this = self.expression(ignore_respect.__class__, this=this)
    4984
    4985        this = self._parse_respect_or_ignore_nulls(this)
    4986
    4987        # bigquery select from window x AS (partition by ...)
    4988        if alias:
    4989            over = None
    4990            self._match(TokenType.ALIAS)
    4991        elif not self._match_set(self.WINDOW_BEFORE_PAREN_TOKENS):
    4992            return this
    4993        else:
    4994            over = self._prev.text.upper()
    4995
    4996        if not self._match(TokenType.L_PAREN):
    4997            return self.expression(
    4998                exp.Window, this=this, alias=self._parse_id_var(False), over=over
    4999            )
    5000
    5001        window_alias = self._parse_id_var(any_token=False, tokens=self.WINDOW_ALIAS_TOKENS)
    5002
    5003        first = self._match(TokenType.FIRST)
    5004        if self._match_text_seq("LAST"):
    5005            first = False
    5006
    5007        partition, order = self._parse_partition_and_order()
    5008        kind = self._match_set((TokenType.ROWS, TokenType.RANGE)) and self._prev.text
    5009
    5010        if kind:
    5011            self._match(TokenType.BETWEEN)
    5012            start = self._parse_window_spec()
    5013            self._match(TokenType.AND)
    5014            end = self._parse_window_spec()
    5015
    5016            spec = self.expression(
    5017                exp.WindowSpec,
    5018                kind=kind,
    5019                start=start["value"],
    5020                start_side=start["side"],
    5021                end=end["value"],
    5022                end_side=end["side"],
    5023            )
    5024        else:
    5025            spec = None
    5026
    5027        self._match_r_paren()
    5028
    5029        window = self.expression(
    5030            exp.Window,
    5031            this=this,
    5032            partition_by=partition,
    5033            order=order,
    5034            spec=spec,
    5035            alias=window_alias,
    5036            over=over,
    5037            first=first,
    5038        )
    5039
    5040        # This covers Oracle's FIRST/LAST syntax: aggregate KEEP (...) OVER (...)
    5041        if self._match_set(self.WINDOW_BEFORE_PAREN_TOKENS, advance=False):
    5042            return self._parse_window(window, alias=alias)
    5043
    5044        return window
    5045
    5046    def _parse_partition_and_order(
    5047        self,
    5048    ) -> t.Tuple[t.List[exp.Expression], t.Optional[exp.Expression]]:
    5049        return self._parse_partition_by(), self._parse_order()
    5050
    5051    def _parse_window_spec(self) -> t.Dict[str, t.Optional[str | exp.Expression]]:
    5052        self._match(TokenType.BETWEEN)
    5053
    5054        return {
    5055            "value": (
    5056                (self._match_text_seq("UNBOUNDED") and "UNBOUNDED")
    5057                or (self._match_text_seq("CURRENT", "ROW") and "CURRENT ROW")
    5058                or self._parse_bitwise()
    5059            ),
    5060            "side": self._match_texts(self.WINDOW_SIDES) and self._prev.text,
    5061        }
    5062
    5063    def _parse_alias(
    5064        self, this: t.Optional[exp.Expression], explicit: bool = False
    5065    ) -> t.Optional[exp.Expression]:
    5066        any_token = self._match(TokenType.ALIAS)
    5067        comments = self._prev_comments
    5068
    5069        if explicit and not any_token:
    5070            return this
    5071
    5072        if self._match(TokenType.L_PAREN):
    5073            aliases = self.expression(
    5074                exp.Aliases,
    5075                comments=comments,
    5076                this=this,
    5077                expressions=self._parse_csv(lambda: self._parse_id_var(any_token)),
    5078            )
    5079            self._match_r_paren(aliases)
    5080            return aliases
    5081
    5082        alias = self._parse_id_var(any_token) or (
    5083            self.STRING_ALIASES and self._parse_string_as_identifier()
    5084        )
    5085
    5086        if alias:
    5087            this = self.expression(exp.Alias, comments=comments, this=this, alias=alias)
    5088            column = this.this
    5089
    5090            # Moves the comment next to the alias in `expr /* comment */ AS alias`
    5091            if not this.comments and column and column.comments:
    5092                this.comments = column.comments
    5093                column.comments = None
    5094
    5095        return this
    5096
    5097    def _parse_id_var(
    5098        self,
    5099        any_token: bool = True,
    5100        tokens: t.Optional[t.Collection[TokenType]] = None,
    5101    ) -> t.Optional[exp.Expression]:
    5102        identifier = self._parse_identifier()
    5103
    5104        if identifier:
    5105            return identifier
    5106
    5107        if (any_token and self._advance_any()) or self._match_set(tokens or self.ID_VAR_TOKENS):
    5108            quoted = self._prev.token_type == TokenType.STRING
    5109            return exp.Identifier(this=self._prev.text, quoted=quoted)
    5110
    5111        return None
    5112
    5113    def _parse_string(self) -> t.Optional[exp.Expression]:
    5114        if self._match_set((TokenType.STRING, TokenType.RAW_STRING)):
    5115            return self.PRIMARY_PARSERS[self._prev.token_type](self, self._prev)
    5116        return self._parse_placeholder()
    5117
    5118    def _parse_string_as_identifier(self) -> t.Optional[exp.Identifier]:
    5119        return exp.to_identifier(self._match(TokenType.STRING) and self._prev.text, quoted=True)
    5120
    5121    def _parse_number(self) -> t.Optional[exp.Expression]:
    5122        if self._match(TokenType.NUMBER):
    5123            return self.PRIMARY_PARSERS[TokenType.NUMBER](self, self._prev)
    5124        return self._parse_placeholder()
    5125
    5126    def _parse_identifier(self) -> t.Optional[exp.Expression]:
    5127        if self._match(TokenType.IDENTIFIER):
    5128            return self.expression(exp.Identifier, this=self._prev.text, quoted=True)
    5129        return self._parse_placeholder()
    5130
    5131    def _parse_var(
    5132        self,
    5133        any_token: bool = False,
    5134        tokens: t.Optional[t.Collection[TokenType]] = None,
    5135        upper: bool = False,
    5136    ) -> t.Optional[exp.Expression]:
    5137        if (
    5138            (any_token and self._advance_any())
    5139            or self._match(TokenType.VAR)
    5140            or (self._match_set(tokens) if tokens else False)
    5141        ):
    5142            return self.expression(
    5143                exp.Var, this=self._prev.text.upper() if upper else self._prev.text
    5144            )
    5145        return self._parse_placeholder()
    5146
    5147    def _advance_any(self, ignore_reserved: bool = False) -> t.Optional[Token]:
    5148        if self._curr and (ignore_reserved or self._curr.token_type not in self.RESERVED_TOKENS):
    5149            self._advance()
    5150            return self._prev
    5151        return None
    5152
    5153    def _parse_var_or_string(self) -> t.Optional[exp.Expression]:
    5154        return self._parse_var() or self._parse_string()
    5155
    5156    def _parse_null(self) -> t.Optional[exp.Expression]:
    5157        if self._match_set(self.NULL_TOKENS):
    5158            return self.PRIMARY_PARSERS[TokenType.NULL](self, self._prev)
    5159        return self._parse_placeholder()
    5160
    5161    def _parse_boolean(self) -> t.Optional[exp.Expression]:
    5162        if self._match(TokenType.TRUE):
    5163            return self.PRIMARY_PARSERS[TokenType.TRUE](self, self._prev)
    5164        if self._match(TokenType.FALSE):
    5165            return self.PRIMARY_PARSERS[TokenType.FALSE](self, self._prev)
    5166        return self._parse_placeholder()
    5167
    5168    def _parse_star(self) -> t.Optional[exp.Expression]:
    5169        if self._match(TokenType.STAR):
    5170            return self.PRIMARY_PARSERS[TokenType.STAR](self, self._prev)
    5171        return self._parse_placeholder()
    5172
    5173    def _parse_parameter(self) -> exp.Parameter:
    5174        def _parse_parameter_part() -> t.Optional[exp.Expression]:
    5175            return (
    5176                self._parse_identifier() or self._parse_primary() or self._parse_var(any_token=True)
    5177            )
    5178
    5179        self._match(TokenType.L_BRACE)
    5180        this = _parse_parameter_part()
    5181        expression = self._match(TokenType.COLON) and _parse_parameter_part()
    5182        self._match(TokenType.R_BRACE)
    5183
    5184        return self.expression(exp.Parameter, this=this, expression=expression)
    5185
    5186    def _parse_placeholder(self) -> t.Optional[exp.Expression]:
    5187        if self._match_set(self.PLACEHOLDER_PARSERS):
    5188            placeholder = self.PLACEHOLDER_PARSERS[self._prev.token_type](self)
    5189            if placeholder:
    5190                return placeholder
    5191            self._advance(-1)
    5192        return None
    5193
    5194    def _parse_except(self) -> t.Optional[t.List[exp.Expression]]:
    5195        if not self._match(TokenType.EXCEPT):
    5196            return None
    5197        if self._match(TokenType.L_PAREN, advance=False):
    5198            return self._parse_wrapped_csv(self._parse_column)
    5199
    5200        except_column = self._parse_column()
    5201        return [except_column] if except_column else None
    5202
    5203    def _parse_replace(self) -> t.Optional[t.List[exp.Expression]]:
    5204        if not self._match(TokenType.REPLACE):
    5205            return None
    5206        if self._match(TokenType.L_PAREN, advance=False):
    5207            return self._parse_wrapped_csv(self._parse_expression)
    5208
    5209        replace_expression = self._parse_expression()
    5210        return [replace_expression] if replace_expression else None
    5211
    5212    def _parse_csv(
    5213        self, parse_method: t.Callable, sep: TokenType = TokenType.COMMA
    5214    ) -> t.List[exp.Expression]:
    5215        parse_result = parse_method()
    5216        items = [parse_result] if parse_result is not None else []
    5217
    5218        while self._match(sep):
    5219            self._add_comments(parse_result)
    5220            parse_result = parse_method()
    5221            if parse_result is not None:
    5222                items.append(parse_result)
    5223
    5224        return items
    5225
    5226    def _parse_tokens(
    5227        self, parse_method: t.Callable, expressions: t.Dict
    5228    ) -> t.Optional[exp.Expression]:
    5229        this = parse_method()
    5230
    5231        while self._match_set(expressions):
    5232            this = self.expression(
    5233                expressions[self._prev.token_type],
    5234                this=this,
    5235                comments=self._prev_comments,
    5236                expression=parse_method(),
    5237            )
    5238
    5239        return this
    5240
    5241    def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
    5242        return self._parse_wrapped_csv(self._parse_id_var, optional=optional)
    5243
    5244    def _parse_wrapped_csv(
    5245        self, parse_method: t.Callable, sep: TokenType = TokenType.COMMA, optional: bool = False
    5246    ) -> t.List[exp.Expression]:
    5247        return self._parse_wrapped(
    5248            lambda: self._parse_csv(parse_method, sep=sep), optional=optional
    5249        )
    5250
    5251    def _parse_wrapped(self, parse_method: t.Callable, optional: bool = False) -> t.Any:
    5252        wrapped = self._match(TokenType.L_PAREN)
    5253        if not wrapped and not optional:
    5254            self.raise_error("Expecting (")
    5255        parse_result = parse_method()
    5256        if wrapped:
    5257            self._match_r_paren()
    5258        return parse_result
    5259
    5260    def _parse_expressions(self) -> t.List[exp.Expression]:
    5261        return self._parse_csv(self._parse_expression)
    5262
    5263    def _parse_select_or_expression(self, alias: bool = False) -> t.Optional[exp.Expression]:
    5264        return self._parse_select() or self._parse_set_operations(
    5265            self._parse_expression() if alias else self._parse_conjunction()
    5266        )
    5267
    5268    def _parse_ddl_select(self) -> t.Optional[exp.Expression]:
    5269        return self._parse_query_modifiers(
    5270            self._parse_set_operations(self._parse_select(nested=True, parse_subquery_alias=False))
    5271        )
    5272
    5273    def _parse_transaction(self) -> exp.Transaction | exp.Command:
    5274        this = None
    5275        if self._match_texts(self.TRANSACTION_KIND):
    5276            this = self._prev.text
    5277
    5278        self._match_texts(("TRANSACTION", "WORK"))
    5279
    5280        modes = []
    5281        while True:
    5282            mode = []
    5283            while self._match(TokenType.VAR):
    5284                mode.append(self._prev.text)
    5285
    5286            if mode:
    5287                modes.append(" ".join(mode))
    5288            if not self._match(TokenType.COMMA):
    5289                break
    5290
    5291        return self.expression(exp.Transaction, this=this, modes=modes)
    5292
    5293    def _parse_commit_or_rollback(self) -> exp.Commit | exp.Rollback:
    5294        chain = None
    5295        savepoint = None
    5296        is_rollback = self._prev.token_type == TokenType.ROLLBACK
    5297
    5298        self._match_texts(("TRANSACTION", "WORK"))
    5299
    5300        if self._match_text_seq("TO"):
    5301            self._match_text_seq("SAVEPOINT")
    5302            savepoint = self._parse_id_var()
    5303
    5304        if self._match(TokenType.AND):
    5305            chain = not self._match_text_seq("NO")
    5306            self._match_text_seq("CHAIN")
    5307
    5308        if is_rollback:
    5309            return self.expression(exp.Rollback, savepoint=savepoint)
    5310
    5311        return self.expression(exp.Commit, chain=chain)
    5312
    5313    def _parse_refresh(self) -> exp.Refresh:
    5314        self._match(TokenType.TABLE)
    5315        return self.expression(exp.Refresh, this=self._parse_string() or self._parse_table())
    5316
    5317    def _parse_add_column(self) -> t.Optional[exp.Expression]:
    5318        if not self._match_text_seq("ADD"):
    5319            return None
    5320
    5321        self._match(TokenType.COLUMN)
    5322        exists_column = self._parse_exists(not_=True)
    5323        expression = self._parse_field_def()
    5324
    5325        if expression:
    5326            expression.set("exists", exists_column)
    5327
    5328            # https://docs.databricks.com/delta/update-schema.html#explicitly-update-schema-to-add-columns
    5329            if self._match_texts(("FIRST", "AFTER")):
    5330                position = self._prev.text
    5331                column_position = self.expression(
    5332                    exp.ColumnPosition, this=self._parse_column(), position=position
    5333                )
    5334                expression.set("position", column_position)
    5335
    5336        return expression
    5337
    5338    def _parse_drop_column(self) -> t.Optional[exp.Drop | exp.Command]:
    5339        drop = self._match(TokenType.DROP) and self._parse_drop()
    5340        if drop and not isinstance(drop, exp.Command):
    5341            drop.set("kind", drop.args.get("kind", "COLUMN"))
    5342        return drop
    5343
    5344    # https://docs.aws.amazon.com/athena/latest/ug/alter-table-drop-partition.html
    5345    def _parse_drop_partition(self, exists: t.Optional[bool] = None) -> exp.DropPartition:
    5346        return self.expression(
    5347            exp.DropPartition, expressions=self._parse_csv(self._parse_partition), exists=exists
    5348        )
    5349
    5350    def _parse_add_constraint(self) -> exp.AddConstraint:
    5351        this = None
    5352        kind = self._prev.token_type
    5353
    5354        if kind == TokenType.CONSTRAINT:
    5355            this = self._parse_id_var()
    5356
    5357            if self._match_text_seq("CHECK"):
    5358                expression = self._parse_wrapped(self._parse_conjunction)
    5359                enforced = self._match_text_seq("ENFORCED") or False
    5360
    5361                return self.expression(
    5362                    exp.AddConstraint, this=this, expression=expression, enforced=enforced
    5363                )
    5364
    5365        if kind == TokenType.FOREIGN_KEY or self._match(TokenType.FOREIGN_KEY):
    5366            expression = self._parse_foreign_key()
    5367        elif kind == TokenType.PRIMARY_KEY or self._match(TokenType.PRIMARY_KEY):
    5368            expression = self._parse_primary_key()
    5369        else:
    5370            expression = None
    5371
    5372        return self.expression(exp.AddConstraint, this=this, expression=expression)
    5373
    5374    def _parse_alter_table_add(self) -> t.List[exp.Expression]:
    5375        index = self._index - 1
    5376
    5377        if self._match_set(self.ADD_CONSTRAINT_TOKENS):
    5378            return self._parse_csv(self._parse_add_constraint)
    5379
    5380        self._retreat(index)
    5381        if not self.ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN and self._match_text_seq("ADD"):
    5382            return self._parse_wrapped_csv(self._parse_field_def, optional=True)
    5383        return self._parse_wrapped_csv(self._parse_add_column, optional=True)
    5384
    5385    def _parse_alter_table_alter(self) -> exp.AlterColumn:
    5386        self._match(TokenType.COLUMN)
    5387        column = self._parse_field(any_token=True)
    5388
    5389        if self._match_pair(TokenType.DROP, TokenType.DEFAULT):
    5390            return self.expression(exp.AlterColumn, this=column, drop=True)
    5391        if self._match_pair(TokenType.SET, TokenType.DEFAULT):
    5392            return self.expression(exp.AlterColumn, this=column, default=self._parse_conjunction())
    5393        if self._match(TokenType.COMMENT):
    5394            return self.expression(exp.AlterColumn, this=column, comment=self._parse_string())
    5395
    5396        self._match_text_seq("SET", "DATA")
    5397        return self.expression(
    5398            exp.AlterColumn,
    5399            this=column,
    5400            dtype=self._match_text_seq("TYPE") and self._parse_types(),
    5401            collate=self._match(TokenType.COLLATE) and self._parse_term(),
    5402            using=self._match(TokenType.USING) and self._parse_conjunction(),
    5403        )
    5404
    5405    def _parse_alter_table_drop(self) -> t.List[exp.Expression]:
    5406        index = self._index - 1
    5407
    5408        partition_exists = self._parse_exists()
    5409        if self._match(TokenType.PARTITION, advance=False):
    5410            return self._parse_csv(lambda: self._parse_drop_partition(exists=partition_exists))
    5411
    5412        self._retreat(index)
    5413        return self._parse_csv(self._parse_drop_column)
    5414
    5415    def _parse_alter_table_rename(self) -> t.Optional[exp.RenameTable | exp.RenameColumn]:
    5416        if self._match(TokenType.COLUMN):
    5417            exists = self._parse_exists()
    5418            old_column = self._parse_column()
    5419            to = self._match_text_seq("TO")
    5420            new_column = self._parse_column()
    5421
    5422            if old_column is None or to is None or new_column is None:
    5423                return None
    5424
    5425            return self.expression(exp.RenameColumn, this=old_column, to=new_column, exists=exists)
    5426
    5427        self._match_text_seq("TO")
    5428        return self.expression(exp.RenameTable, this=self._parse_table(schema=True))
    5429
    5430    def _parse_alter(self) -> exp.AlterTable | exp.Command:
    5431        start = self._prev
    5432
    5433        if not self._match(TokenType.TABLE):
    5434            return self._parse_as_command(start)
    5435
    5436        exists = self._parse_exists()
    5437        only = self._match_text_seq("ONLY")
    5438        this = self._parse_table(schema=True)
    5439
    5440        if self._next:
    5441            self._advance()
    5442
    5443        parser = self.ALTER_PARSERS.get(self._prev.text.upper()) if self._prev else None
    5444        if parser:
    5445            actions = ensure_list(parser(self))
    5446
    5447            if not self._curr and actions:
    5448                return self.expression(
    5449                    exp.AlterTable,
    5450                    this=this,
    5451                    exists=exists,
    5452                    actions=actions,
    5453                    only=only,
    5454                )
    5455
    5456        return self._parse_as_command(start)
    5457
    5458    def _parse_merge(self) -> exp.Merge:
    5459        self._match(TokenType.INTO)
    5460        target = self._parse_table()
    5461
    5462        if target and self._match(TokenType.ALIAS, advance=False):
    5463            target.set("alias", self._parse_table_alias())
    5464
    5465        self._match(TokenType.USING)
    5466        using = self._parse_table()
    5467
    5468        self._match(TokenType.ON)
    5469        on = self._parse_conjunction()
    5470
    5471        return self.expression(
    5472            exp.Merge,
    5473            this=target,
    5474            using=using,
    5475            on=on,
    5476            expressions=self._parse_when_matched(),
    5477        )
    5478
    5479    def _parse_when_matched(self) -> t.List[exp.When]:
    5480        whens = []
    5481
    5482        while self._match(TokenType.WHEN):
    5483            matched = not self._match(TokenType.NOT)
    5484            self._match_text_seq("MATCHED")
    5485            source = (
    5486                False
    5487                if self._match_text_seq("BY", "TARGET")
    5488                else self._match_text_seq("BY", "SOURCE")
    5489            )
    5490            condition = self._parse_conjunction() if self._match(TokenType.AND) else None
    5491
    5492            self._match(TokenType.THEN)
    5493
    5494            if self._match(TokenType.INSERT):
    5495                _this = self._parse_star()
    5496                if _this:
    5497                    then: t.Optional[exp.Expression] = self.expression(exp.Insert, this=_this)
    5498                else:
    5499                    then = self.expression(
    5500                        exp.Insert,
    5501                        this=self._parse_value(),
    5502                        expression=self._match(TokenType.VALUES) and self._parse_value(),
    5503                    )
    5504            elif self._match(TokenType.UPDATE):
    5505                expressions = self._parse_star()
    5506                if expressions:
    5507                    then = self.expression(exp.Update, expressions=expressions)
    5508                else:
    5509                    then = self.expression(
    5510                        exp.Update,
    5511                        expressions=self._match(TokenType.SET)
    5512                        and self._parse_csv(self._parse_equality),
    5513                    )
    5514            elif self._match(TokenType.DELETE):
    5515                then = self.expression(exp.Var, this=self._prev.text)
    5516            else:
    5517                then = None
    5518
    5519            whens.append(
    5520                self.expression(
    5521                    exp.When,
    5522                    matched=matched,
    5523                    source=source,
    5524                    condition=condition,
    5525                    then=then,
    5526                )
    5527            )
    5528        return whens
    5529
    5530    def _parse_show(self) -> t.Optional[exp.Expression]:
    5531        parser = self._find_parser(self.SHOW_PARSERS, self.SHOW_TRIE)
    5532        if parser:
    5533            return parser(self)
    5534        return self._parse_as_command(self._prev)
    5535
    5536    def _parse_set_item_assignment(
    5537        self, kind: t.Optional[str] = None
    5538    ) -> t.Optional[exp.Expression]:
    5539        index = self._index
    5540
    5541        if kind in ("GLOBAL", "SESSION") and self._match_text_seq("TRANSACTION"):
    5542            return self._parse_set_transaction(global_=kind == "GLOBAL")
    5543
    5544        left = self._parse_primary() or self._parse_id_var()
    5545        assignment_delimiter = self._match_texts(("=", "TO"))
    5546
    5547        if not left or (self.SET_REQUIRES_ASSIGNMENT_DELIMITER and not assignment_delimiter):
    5548            self._retreat(index)
    5549            return None
    5550
    5551        right = self._parse_statement() or self._parse_id_var()
    5552        this = self.expression(exp.EQ, this=left, expression=right)
    5553
    5554        return self.expression(exp.SetItem, this=this, kind=kind)
    5555
    5556    def _parse_set_transaction(self, global_: bool = False) -> exp.Expression:
    5557        self._match_text_seq("TRANSACTION")
    5558        characteristics = self._parse_csv(
    5559            lambda: self._parse_var_from_options(self.TRANSACTION_CHARACTERISTICS)
    5560        )
    5561        return self.expression(
    5562            exp.SetItem,
    5563            expressions=characteristics,
    5564            kind="TRANSACTION",
    5565            **{"global": global_},  # type: ignore
    5566        )
    5567
    5568    def _parse_set_item(self) -> t.Optional[exp.Expression]:
    5569        parser = self._find_parser(self.SET_PARSERS, self.SET_TRIE)
    5570        return parser(self) if parser else self._parse_set_item_assignment(kind=None)
    5571
    5572    def _parse_set(self, unset: bool = False, tag: bool = False) -> exp.Set | exp.Command:
    5573        index = self._index
    5574        set_ = self.expression(
    5575            exp.Set, expressions=self._parse_csv(self._parse_set_item), unset=unset, tag=tag
    5576        )
    5577
    5578        if self._curr:
    5579            self._retreat(index)
    5580            return self._parse_as_command(self._prev)
    5581
    5582        return set_
    5583
    5584    def _parse_var_from_options(self, options: t.Collection[str]) -> t.Optional[exp.Var]:
    5585        for option in options:
    5586            if self._match_text_seq(*option.split(" ")):
    5587                return exp.var(option)
    5588        return None
    5589
    5590    def _parse_as_command(self, start: Token) -> exp.Command:
    5591        while self._curr:
    5592            self._advance()
    5593        text = self._find_sql(start, self._prev)
    5594        size = len(start.text)
    5595        self._warn_unsupported()
    5596        return exp.Command(this=text[:size], expression=text[size:])
    5597
    5598    def _parse_dict_property(self, this: str) -> exp.DictProperty:
    5599        settings = []
    5600
    5601        self._match_l_paren()
    5602        kind = self._parse_id_var()
    5603
    5604        if self._match(TokenType.L_PAREN):
    5605            while True:
    5606                key = self._parse_id_var()
    5607                value = self._parse_primary()
    5608
    5609                if not key and value is None:
    5610                    break
    5611                settings.append(self.expression(exp.DictSubProperty, this=key, value=value))
    5612            self._match(TokenType.R_PAREN)
    5613
    5614        self._match_r_paren()
    5615
    5616        return self.expression(
    5617            exp.DictProperty,
    5618            this=this,
    5619            kind=kind.this if kind else None,
    5620            settings=settings,
    5621        )
    5622
    5623    def _parse_dict_range(self, this: str) -> exp.DictRange:
    5624        self._match_l_paren()
    5625        has_min = self._match_text_seq("MIN")
    5626        if has_min:
    5627            min = self._parse_var() or self._parse_primary()
    5628            self._match_text_seq("MAX")
    5629            max = self._parse_var() or self._parse_primary()
    5630        else:
    5631            max = self._parse_var() or self._parse_primary()
    5632            min = exp.Literal.number(0)
    5633        self._match_r_paren()
    5634        return self.expression(exp.DictRange, this=this, min=min, max=max)
    5635
    5636    def _parse_comprehension(
    5637        self, this: t.Optional[exp.Expression]
    5638    ) -> t.Optional[exp.Comprehension]:
    5639        index = self._index
    5640        expression = self._parse_column()
    5641        if not self._match(TokenType.IN):
    5642            self._retreat(index - 1)
    5643            return None
    5644        iterator = self._parse_column()
    5645        condition = self._parse_conjunction() if self._match_text_seq("IF") else None
    5646        return self.expression(
    5647            exp.Comprehension,
    5648            this=this,
    5649            expression=expression,
    5650            iterator=iterator,
    5651            condition=condition,
    5652        )
    5653
    5654    def _parse_heredoc(self) -> t.Optional[exp.Heredoc]:
    5655        if self._match(TokenType.HEREDOC_STRING):
    5656            return self.expression(exp.Heredoc, this=self._prev.text)
    5657
    5658        if not self._match_text_seq("$"):
    5659            return None
    5660
    5661        tags = ["$"]
    5662        tag_text = None
    5663
    5664        if self._is_connected():
    5665            self._advance()
    5666            tags.append(self._prev.text.upper())
    5667        else:
    5668            self.raise_error("No closing $ found")
    5669
    5670        if tags[-1] != "$":
    5671            if self._is_connected() and self._match_text_seq("$"):
    5672                tag_text = tags[-1]
    5673                tags.append("$")
    5674            else:
    5675                self.raise_error("No closing $ found")
    5676
    5677        heredoc_start = self._curr
    5678
    5679        while self._curr:
    5680            if self._match_text_seq(*tags, advance=False):
    5681                this = self._find_sql(heredoc_start, self._prev)
    5682                self._advance(len(tags))
    5683                return self.expression(exp.Heredoc, this=this, tag=tag_text)
    5684
    5685            self._advance()
    5686
    5687        self.raise_error(f"No closing {''.join(tags)} found")
    5688        return None
    5689
    5690    def _find_parser(
    5691        self, parsers: t.Dict[str, t.Callable], trie: t.Dict
    5692    ) -> t.Optional[t.Callable]:
    5693        if not self._curr:
    5694            return None
    5695
    5696        index = self._index
    5697        this = []
    5698        while True:
    5699            # The current token might be multiple words
    5700            curr = self._curr.text.upper()
    5701            key = curr.split(" ")
    5702            this.append(curr)
    5703
    5704            self._advance()
    5705            result, trie = in_trie(trie, key)
    5706            if result == TrieResult.FAILED:
    5707                break
    5708
    5709            if result == TrieResult.EXISTS:
    5710                subparser = parsers[" ".join(this)]
    5711                return subparser
    5712
    5713        self._retreat(index)
    5714        return None
    5715
    5716    def _match(self, token_type, advance=True, expression=None):
    5717        if not self._curr:
    5718            return None
    5719
    5720        if self._curr.token_type == token_type:
    5721            if advance:
    5722                self._advance()
    5723            self._add_comments(expression)
    5724            return True
    5725
    5726        return None
    5727
    5728    def _match_set(self, types, advance=True):
    5729        if not self._curr:
    5730            return None
    5731
    5732        if self._curr.token_type in types:
    5733            if advance:
    5734                self._advance()
    5735            return True
    5736
    5737        return None
    5738
    5739    def _match_pair(self, token_type_a, token_type_b, advance=True):
    5740        if not self._curr or not self._next:
    5741            return None
    5742
    5743        if self._curr.token_type == token_type_a and self._next.token_type == token_type_b:
    5744            if advance:
    5745                self._advance(2)
    5746            return True
    5747
    5748        return None
    5749
    5750    def _match_l_paren(self, expression: t.Optional[exp.Expression] = None) -> None:
    5751        if not self._match(TokenType.L_PAREN, expression=expression):
    5752            self.raise_error("Expecting (")
    5753
    5754    def _match_r_paren(self, expression: t.Optional[exp.Expression] = None) -> None:
    5755        if not self._match(TokenType.R_PAREN, expression=expression):
    5756            self.raise_error("Expecting )")
    5757
    5758    def _match_texts(self, texts, advance=True):
    5759        if self._curr and self._curr.text.upper() in texts:
    5760            if advance:
    5761                self._advance()
    5762            return True
    5763        return None
    5764
    5765    def _match_text_seq(self, *texts, advance=True):
    5766        index = self._index
    5767        for text in texts:
    5768            if self._curr and self._curr.text.upper() == text:
    5769                self._advance()
    5770            else:
    5771                self._retreat(index)
    5772                return None
    5773
    5774        if not advance:
    5775            self._retreat(index)
    5776
    5777        return True
    5778
    5779    @t.overload
    5780    def _replace_columns_with_dots(self, this: exp.Expression) -> exp.Expression:
    5781        ...
    5782
    5783    @t.overload
    5784    def _replace_columns_with_dots(
    5785        self, this: t.Optional[exp.Expression]
    5786    ) -> t.Optional[exp.Expression]:
    5787        ...
    5788
    5789    def _replace_columns_with_dots(self, this):
    5790        if isinstance(this, exp.Dot):
    5791            exp.replace_children(this, self._replace_columns_with_dots)
    5792        elif isinstance(this, exp.Column):
    5793            exp.replace_children(this, self._replace_columns_with_dots)
    5794            table = this.args.get("table")
    5795            this = (
    5796                self.expression(exp.Dot, this=table, expression=this.this) if table else this.this
    5797            )
    5798
    5799        return this
    5800
    5801    def _replace_lambda(
    5802        self, node: t.Optional[exp.Expression], lambda_variables: t.Set[str]
    5803    ) -> t.Optional[exp.Expression]:
    5804        if not node:
    5805            return node
    5806
    5807        for column in node.find_all(exp.Column):
    5808            if column.parts[0].name in lambda_variables:
    5809                dot_or_id = column.to_dot() if column.table else column.this
    5810                parent = column.parent
    5811
    5812                while isinstance(parent, exp.Dot):
    5813                    if not isinstance(parent.parent, exp.Dot):
    5814                        parent.replace(dot_or_id)
    5815                        break
    5816                    parent = parent.parent
    5817                else:
    5818                    if column is node:
    5819                        node = dot_or_id
    5820                    else:
    5821                        column.replace(dot_or_id)
    5822        return node

logger = <Logger sqlglot (WARNING)>
def parse_var_map(args: List) -> sqlglot.expressions.StarMap | sqlglot.expressions.VarMap: View Source

    22def parse_var_map(args: t.List) -> exp.StarMap | exp.VarMap:
    23    if len(args) == 1 and args[0].is_star:
    24        return exp.StarMap(this=args[0])
    25
    26    keys = []
    27    values = []
    28    for i in range(0, len(args), 2):
    29        keys.append(args[i])
    30        values.append(args[i + 1])
    31
    32    return exp.VarMap(
    33        keys=exp.Array(expressions=keys),
    34        values=exp.Array(expressions=values),
    35    )

def parse_like(args: List) -> sqlglot.expressions.Escape | sqlglot.expressions.Like: View Source

    38def parse_like(args: t.List) -> exp.Escape | exp.Like:
    39    like = exp.Like(this=seq_get(args, 1), expression=seq_get(args, 0))
    40    return exp.Escape(this=like, expression=seq_get(args, 2)) if len(args) > 2 else like

def binary_range_parser( expr_type: Type[sqlglot.expressions.Expression]) -> Callable[[Parser, Optional[sqlglot.expressions.Expression]], Optional[sqlglot.expressions.Expression]]: View Source

    43def binary_range_parser(
    44    expr_type: t.Type[exp.Expression],
    45) -> t.Callable[[Parser, t.Optional[exp.Expression]], t.Optional[exp.Expression]]:
    46    return lambda self, this: self._parse_escape(
    47        self.expression(expr_type, this=this, expression=self._parse_bitwise())
    48    )

def parse_logarithm( args: List, dialect: sqlglot.dialects.dialect.Dialect) -> sqlglot.expressions.Func: View Source

    51def parse_logarithm(args: t.List, dialect: Dialect) -> exp.Func:
    52    # Default argument order is base, expression
    53    this = seq_get(args, 0)
    54    expression = seq_get(args, 1)
    55
    56    if expression:
    57        if not dialect.LOG_BASE_FIRST:
    58            this, expression = expression, this
    59        return exp.Log(this=this, expression=expression)
    60
    61    return (exp.Ln if dialect.parser_class.LOG_DEFAULTS_TO_LN else exp.Log)(this=this)

def parse_extract_json_with_path( expr_type: Type[~E]) -> Callable[[List, sqlglot.dialects.dialect.Dialect], ~E]: View Source

    64def parse_extract_json_with_path(expr_type: t.Type[E]) -> t.Callable[[t.List, Dialect], E]:
    65    def _parser(args: t.List, dialect: Dialect) -> E:
    66        expression = expr_type(
    67            this=seq_get(args, 0), expression=dialect.to_json_path(seq_get(args, 1))
    68        )
    69        if len(args) > 2 and expr_type is exp.JSONExtract:
    70            expression.set("expressions", args[2:])
    71
    72        return expression
    73
    74    return _parser

class Parser: View Source

      87class Parser(metaclass=_Parser):
      88    """
      89    Parser consumes a list of tokens produced by the Tokenizer and produces a parsed syntax tree.
      90
      91    Args:
      92        error_level: The desired error level.
      93            Default: ErrorLevel.IMMEDIATE
      94        error_message_context: Determines the amount of context to capture from a
      95            query string when displaying the error message (in number of characters).
      96            Default: 100
      97        max_errors: Maximum number of error messages to include in a raised ParseError.
      98            This is only relevant if error_level is ErrorLevel.RAISE.
      99            Default: 3
     100    """
     101
     102    FUNCTIONS: t.Dict[str, t.Callable] = {
     103        **{name: func.from_arg_list for name, func in exp.FUNCTION_BY_NAME.items()},
     104        "CONCAT": lambda args, dialect: exp.Concat(
     105            expressions=args,
     106            safe=not dialect.STRICT_STRING_CONCAT,
     107            coalesce=dialect.CONCAT_COALESCE,
     108        ),
     109        "CONCAT_WS": lambda args, dialect: exp.ConcatWs(
     110            expressions=args,
     111            safe=not dialect.STRICT_STRING_CONCAT,
     112            coalesce=dialect.CONCAT_COALESCE,
     113        ),
     114        "DATE_TO_DATE_STR": lambda args: exp.Cast(
     115            this=seq_get(args, 0),
     116            to=exp.DataType(this=exp.DataType.Type.TEXT),
     117        ),
     118        "GLOB": lambda args: exp.Glob(this=seq_get(args, 1), expression=seq_get(args, 0)),
     119        "JSON_EXTRACT": parse_extract_json_with_path(exp.JSONExtract),
     120        "JSON_EXTRACT_SCALAR": parse_extract_json_with_path(exp.JSONExtractScalar),
     121        "JSON_EXTRACT_PATH_TEXT": parse_extract_json_with_path(exp.JSONExtractScalar),
     122        "LIKE": parse_like,
     123        "LOG": parse_logarithm,
     124        "TIME_TO_TIME_STR": lambda args: exp.Cast(
     125            this=seq_get(args, 0),
     126            to=exp.DataType(this=exp.DataType.Type.TEXT),
     127        ),
     128        "TS_OR_DS_TO_DATE_STR": lambda args: exp.Substring(
     129            this=exp.Cast(
     130                this=seq_get(args, 0),
     131                to=exp.DataType(this=exp.DataType.Type.TEXT),
     132            ),
     133            start=exp.Literal.number(1),
     134            length=exp.Literal.number(10),
     135        ),
     136        "VAR_MAP": parse_var_map,
     137    }
     138
     139    NO_PAREN_FUNCTIONS = {
     140        TokenType.CURRENT_DATE: exp.CurrentDate,
     141        TokenType.CURRENT_DATETIME: exp.CurrentDate,
     142        TokenType.CURRENT_TIME: exp.CurrentTime,
     143        TokenType.CURRENT_TIMESTAMP: exp.CurrentTimestamp,
     144        TokenType.CURRENT_USER: exp.CurrentUser,
     145    }
     146
     147    STRUCT_TYPE_TOKENS = {
     148        TokenType.NESTED,
     149        TokenType.STRUCT,
     150    }
     151
     152    NESTED_TYPE_TOKENS = {
     153        TokenType.ARRAY,
     154        TokenType.LOWCARDINALITY,
     155        TokenType.MAP,
     156        TokenType.NULLABLE,
     157        *STRUCT_TYPE_TOKENS,
     158    }
     159
     160    ENUM_TYPE_TOKENS = {
     161        TokenType.ENUM,
     162        TokenType.ENUM8,
     163        TokenType.ENUM16,
     164    }
     165
     166    AGGREGATE_TYPE_TOKENS = {
     167        TokenType.AGGREGATEFUNCTION,
     168        TokenType.SIMPLEAGGREGATEFUNCTION,
     169    }
     170
     171    TYPE_TOKENS = {
     172        TokenType.BIT,
     173        TokenType.BOOLEAN,
     174        TokenType.TINYINT,
     175        TokenType.UTINYINT,
     176        TokenType.SMALLINT,
     177        TokenType.USMALLINT,
     178        TokenType.INT,
     179        TokenType.UINT,
     180        TokenType.BIGINT,
     181        TokenType.UBIGINT,
     182        TokenType.INT128,
     183        TokenType.UINT128,
     184        TokenType.INT256,
     185        TokenType.UINT256,
     186        TokenType.MEDIUMINT,
     187        TokenType.UMEDIUMINT,
     188        TokenType.FIXEDSTRING,
     189        TokenType.FLOAT,
     190        TokenType.DOUBLE,
     191        TokenType.CHAR,
     192        TokenType.NCHAR,
     193        TokenType.VARCHAR,
     194        TokenType.NVARCHAR,
     195        TokenType.BPCHAR,
     196        TokenType.TEXT,
     197        TokenType.MEDIUMTEXT,
     198        TokenType.LONGTEXT,
     199        TokenType.MEDIUMBLOB,
     200        TokenType.LONGBLOB,
     201        TokenType.BINARY,
     202        TokenType.VARBINARY,
     203        TokenType.JSON,
     204        TokenType.JSONB,
     205        TokenType.INTERVAL,
     206        TokenType.TINYBLOB,
     207        TokenType.TINYTEXT,
     208        TokenType.TIME,
     209        TokenType.TIMETZ,
     210        TokenType.TIMESTAMP,
     211        TokenType.TIMESTAMP_S,
     212        TokenType.TIMESTAMP_MS,
     213        TokenType.TIMESTAMP_NS,
     214        TokenType.TIMESTAMPTZ,
     215        TokenType.TIMESTAMPLTZ,
     216        TokenType.DATETIME,
     217        TokenType.DATETIME64,
     218        TokenType.DATE,
     219        TokenType.DATE32,
     220        TokenType.INT4RANGE,
     221        TokenType.INT4MULTIRANGE,
     222        TokenType.INT8RANGE,
     223        TokenType.INT8MULTIRANGE,
     224        TokenType.NUMRANGE,
     225        TokenType.NUMMULTIRANGE,
     226        TokenType.TSRANGE,
     227        TokenType.TSMULTIRANGE,
     228        TokenType.TSTZRANGE,
     229        TokenType.TSTZMULTIRANGE,
     230        TokenType.DATERANGE,
     231        TokenType.DATEMULTIRANGE,
     232        TokenType.DECIMAL,
     233        TokenType.UDECIMAL,
     234        TokenType.BIGDECIMAL,
     235        TokenType.UUID,
     236        TokenType.GEOGRAPHY,
     237        TokenType.GEOMETRY,
     238        TokenType.HLLSKETCH,
     239        TokenType.HSTORE,
     240        TokenType.PSEUDO_TYPE,
     241        TokenType.SUPER,
     242        TokenType.SERIAL,
     243        TokenType.SMALLSERIAL,
     244        TokenType.BIGSERIAL,
     245        TokenType.XML,
     246        TokenType.YEAR,
     247        TokenType.UNIQUEIDENTIFIER,
     248        TokenType.USERDEFINED,
     249        TokenType.MONEY,
     250        TokenType.SMALLMONEY,
     251        TokenType.ROWVERSION,
     252        TokenType.IMAGE,
     253        TokenType.VARIANT,
     254        TokenType.OBJECT,
     255        TokenType.OBJECT_IDENTIFIER,
     256        TokenType.INET,
     257        TokenType.IPADDRESS,
     258        TokenType.IPPREFIX,
     259        TokenType.IPV4,
     260        TokenType.IPV6,
     261        TokenType.UNKNOWN,
     262        TokenType.NULL,
     263        *ENUM_TYPE_TOKENS,
     264        *NESTED_TYPE_TOKENS,
     265        *AGGREGATE_TYPE_TOKENS,
     266    }
     267
     268    SIGNED_TO_UNSIGNED_TYPE_TOKEN = {
     269        TokenType.BIGINT: TokenType.UBIGINT,
     270        TokenType.INT: TokenType.UINT,
     271        TokenType.MEDIUMINT: TokenType.UMEDIUMINT,
     272        TokenType.SMALLINT: TokenType.USMALLINT,
     273        TokenType.TINYINT: TokenType.UTINYINT,
     274        TokenType.DECIMAL: TokenType.UDECIMAL,
     275    }
     276
     277    SUBQUERY_PREDICATES = {
     278        TokenType.ANY: exp.Any,
     279        TokenType.ALL: exp.All,
     280        TokenType.EXISTS: exp.Exists,
     281        TokenType.SOME: exp.Any,
     282    }
     283
     284    RESERVED_TOKENS = {
     285        *Tokenizer.SINGLE_TOKENS.values(),
     286        TokenType.SELECT,
     287    }
     288
     289    DB_CREATABLES = {
     290        TokenType.DATABASE,
     291        TokenType.SCHEMA,
     292        TokenType.TABLE,
     293        TokenType.VIEW,
     294        TokenType.MODEL,
     295        TokenType.DICTIONARY,
     296    }
     297
     298    CREATABLES = {
     299        TokenType.COLUMN,
     300        TokenType.CONSTRAINT,
     301        TokenType.FUNCTION,
     302        TokenType.INDEX,
     303        TokenType.PROCEDURE,
     304        TokenType.FOREIGN_KEY,
     305        *DB_CREATABLES,
     306    }
     307
     308    # Tokens that can represent identifiers
     309    ID_VAR_TOKENS = {
     310        TokenType.VAR,
     311        TokenType.ANTI,
     312        TokenType.APPLY,
     313        TokenType.ASC,
     314        TokenType.AUTO_INCREMENT,
     315        TokenType.BEGIN,
     316        TokenType.BPCHAR,
     317        TokenType.CACHE,
     318        TokenType.CASE,
     319        TokenType.COLLATE,
     320        TokenType.COMMAND,
     321        TokenType.COMMENT,
     322        TokenType.COMMIT,
     323        TokenType.CONSTRAINT,
     324        TokenType.DEFAULT,
     325        TokenType.DELETE,
     326        TokenType.DESC,
     327        TokenType.DESCRIBE,
     328        TokenType.DICTIONARY,
     329        TokenType.DIV,
     330        TokenType.END,
     331        TokenType.EXECUTE,
     332        TokenType.ESCAPE,
     333        TokenType.FALSE,
     334        TokenType.FIRST,
     335        TokenType.FILTER,
     336        TokenType.FINAL,
     337        TokenType.FORMAT,
     338        TokenType.FULL,
     339        TokenType.IS,
     340        TokenType.ISNULL,
     341        TokenType.INTERVAL,
     342        TokenType.KEEP,
     343        TokenType.KILL,
     344        TokenType.LEFT,
     345        TokenType.LOAD,
     346        TokenType.MERGE,
     347        TokenType.NATURAL,
     348        TokenType.NEXT,
     349        TokenType.OFFSET,
     350        TokenType.OPERATOR,
     351        TokenType.ORDINALITY,
     352        TokenType.OVERLAPS,
     353        TokenType.OVERWRITE,
     354        TokenType.PARTITION,
     355        TokenType.PERCENT,
     356        TokenType.PIVOT,
     357        TokenType.PRAGMA,
     358        TokenType.RANGE,
     359        TokenType.RECURSIVE,
     360        TokenType.REFERENCES,
     361        TokenType.REFRESH,
     362        TokenType.REPLACE,
     363        TokenType.RIGHT,
     364        TokenType.ROW,
     365        TokenType.ROWS,
     366        TokenType.SEMI,
     367        TokenType.SET,
     368        TokenType.SETTINGS,
     369        TokenType.SHOW,
     370        TokenType.TEMPORARY,
     371        TokenType.TOP,
     372        TokenType.TRUE,
     373        TokenType.UNIQUE,
     374        TokenType.UNPIVOT,
     375        TokenType.UPDATE,
     376        TokenType.USE,
     377        TokenType.VOLATILE,
     378        TokenType.WINDOW,
     379        *CREATABLES,
     380        *SUBQUERY_PREDICATES,
     381        *TYPE_TOKENS,
     382        *NO_PAREN_FUNCTIONS,
     383    }
     384
     385    INTERVAL_VARS = ID_VAR_TOKENS - {TokenType.END}
     386
     387    TABLE_ALIAS_TOKENS = ID_VAR_TOKENS - {
     388        TokenType.ANTI,
     389        TokenType.APPLY,
     390        TokenType.ASOF,
     391        TokenType.FULL,
     392        TokenType.LEFT,
     393        TokenType.LOCK,
     394        TokenType.NATURAL,
     395        TokenType.OFFSET,
     396        TokenType.RIGHT,
     397        TokenType.SEMI,
     398        TokenType.WINDOW,
     399    }
     400
     401    COMMENT_TABLE_ALIAS_TOKENS = TABLE_ALIAS_TOKENS - {TokenType.IS}
     402
     403    UPDATE_ALIAS_TOKENS = TABLE_ALIAS_TOKENS - {TokenType.SET}
     404
     405    TRIM_TYPES = {"LEADING", "TRAILING", "BOTH"}
     406
     407    FUNC_TOKENS = {
     408        TokenType.COLLATE,
     409        TokenType.COMMAND,
     410        TokenType.CURRENT_DATE,
     411        TokenType.CURRENT_DATETIME,
     412        TokenType.CURRENT_TIMESTAMP,
     413        TokenType.CURRENT_TIME,
     414        TokenType.CURRENT_USER,
     415        TokenType.FILTER,
     416        TokenType.FIRST,
     417        TokenType.FORMAT,
     418        TokenType.GLOB,
     419        TokenType.IDENTIFIER,
     420        TokenType.INDEX,
     421        TokenType.ISNULL,
     422        TokenType.ILIKE,
     423        TokenType.INSERT,
     424        TokenType.LIKE,
     425        TokenType.MERGE,
     426        TokenType.OFFSET,
     427        TokenType.PRIMARY_KEY,
     428        TokenType.RANGE,
     429        TokenType.REPLACE,
     430        TokenType.RLIKE,
     431        TokenType.ROW,
     432        TokenType.UNNEST,
     433        TokenType.VAR,
     434        TokenType.LEFT,
     435        TokenType.RIGHT,
     436        TokenType.DATE,
     437        TokenType.DATETIME,
     438        TokenType.TABLE,
     439        TokenType.TIMESTAMP,
     440        TokenType.TIMESTAMPTZ,
     441        TokenType.WINDOW,
     442        TokenType.XOR,
     443        *TYPE_TOKENS,
     444        *SUBQUERY_PREDICATES,
     445    }
     446
     447    CONJUNCTION = {
     448        TokenType.AND: exp.And,
     449        TokenType.OR: exp.Or,
     450    }
     451
     452    EQUALITY = {
     453        TokenType.COLON_EQ: exp.PropertyEQ,
     454        TokenType.EQ: exp.EQ,
     455        TokenType.NEQ: exp.NEQ,
     456        TokenType.NULLSAFE_EQ: exp.NullSafeEQ,
     457    }
     458
     459    COMPARISON = {
     460        TokenType.GT: exp.GT,
     461        TokenType.GTE: exp.GTE,
     462        TokenType.LT: exp.LT,
     463        TokenType.LTE: exp.LTE,
     464    }
     465
     466    BITWISE = {
     467        TokenType.AMP: exp.BitwiseAnd,
     468        TokenType.CARET: exp.BitwiseXor,
     469        TokenType.PIPE: exp.BitwiseOr,
     470    }
     471
     472    TERM = {
     473        TokenType.DASH: exp.Sub,
     474        TokenType.PLUS: exp.Add,
     475        TokenType.MOD: exp.Mod,
     476        TokenType.COLLATE: exp.Collate,
     477    }
     478
     479    FACTOR = {
     480        TokenType.DIV: exp.IntDiv,
     481        TokenType.LR_ARROW: exp.Distance,
     482        TokenType.SLASH: exp.Div,
     483        TokenType.STAR: exp.Mul,
     484    }
     485
     486    EXPONENT: t.Dict[TokenType, t.Type[exp.Expression]] = {}
     487
     488    TIMES = {
     489        TokenType.TIME,
     490        TokenType.TIMETZ,
     491    }
     492
     493    TIMESTAMPS = {
     494        TokenType.TIMESTAMP,
     495        TokenType.TIMESTAMPTZ,
     496        TokenType.TIMESTAMPLTZ,
     497        *TIMES,
     498    }
     499
     500    SET_OPERATIONS = {
     501        TokenType.UNION,
     502        TokenType.INTERSECT,
     503        TokenType.EXCEPT,
     504    }
     505
     506    JOIN_METHODS = {
     507        TokenType.NATURAL,
     508        TokenType.ASOF,
     509    }
     510
     511    JOIN_SIDES = {
     512        TokenType.LEFT,
     513        TokenType.RIGHT,
     514        TokenType.FULL,
     515    }
     516
     517    JOIN_KINDS = {
     518        TokenType.INNER,
     519        TokenType.OUTER,
     520        TokenType.CROSS,
     521        TokenType.SEMI,
     522        TokenType.ANTI,
     523    }
     524
     525    JOIN_HINTS: t.Set[str] = set()
     526
     527    LAMBDAS = {
     528        TokenType.ARROW: lambda self, expressions: self.expression(
     529            exp.Lambda,
     530            this=self._replace_lambda(
     531                self._parse_conjunction(),
     532                {node.name for node in expressions},
     533            ),
     534            expressions=expressions,
     535        ),
     536        TokenType.FARROW: lambda self, expressions: self.expression(
     537            exp.Kwarg,
     538            this=exp.var(expressions[0].name),
     539            expression=self._parse_conjunction(),
     540        ),
     541    }
     542
     543    COLUMN_OPERATORS = {
     544        TokenType.DOT: None,
     545        TokenType.DCOLON: lambda self, this, to: self.expression(
     546            exp.Cast if self.STRICT_CAST else exp.TryCast,
     547            this=this,
     548            to=to,
     549        ),
     550        TokenType.ARROW: lambda self, this, path: self.expression(
     551            exp.JSONExtract,
     552            this=this,
     553            expression=self.dialect.to_json_path(path),
     554        ),
     555        TokenType.DARROW: lambda self, this, path: self.expression(
     556            exp.JSONExtractScalar,
     557            this=this,
     558            expression=self.dialect.to_json_path(path),
     559        ),
     560        TokenType.HASH_ARROW: lambda self, this, path: self.expression(
     561            exp.JSONBExtract,
     562            this=this,
     563            expression=path,
     564        ),
     565        TokenType.DHASH_ARROW: lambda self, this, path: self.expression(
     566            exp.JSONBExtractScalar,
     567            this=this,
     568            expression=path,
     569        ),
     570        TokenType.PLACEHOLDER: lambda self, this, key: self.expression(
     571            exp.JSONBContains,
     572            this=this,
     573            expression=key,
     574        ),
     575    }
     576
     577    EXPRESSION_PARSERS = {
     578        exp.Cluster: lambda self: self._parse_sort(exp.Cluster, TokenType.CLUSTER_BY),
     579        exp.Column: lambda self: self._parse_column(),
     580        exp.Condition: lambda self: self._parse_conjunction(),
     581        exp.DataType: lambda self: self._parse_types(allow_identifiers=False),
     582        exp.Expression: lambda self: self._parse_statement(),
     583        exp.From: lambda self: self._parse_from(),
     584        exp.Group: lambda self: self._parse_group(),
     585        exp.Having: lambda self: self._parse_having(),
     586        exp.Identifier: lambda self: self._parse_id_var(),
     587        exp.Join: lambda self: self._parse_join(),
     588        exp.Lambda: lambda self: self._parse_lambda(),
     589        exp.Lateral: lambda self: self._parse_lateral(),
     590        exp.Limit: lambda self: self._parse_limit(),
     591        exp.Offset: lambda self: self._parse_offset(),
     592        exp.Order: lambda self: self._parse_order(),
     593        exp.Ordered: lambda self: self._parse_ordered(),
     594        exp.Properties: lambda self: self._parse_properties(),
     595        exp.Qualify: lambda self: self._parse_qualify(),
     596        exp.Returning: lambda self: self._parse_returning(),
     597        exp.Sort: lambda self: self._parse_sort(exp.Sort, TokenType.SORT_BY),
     598        exp.Table: lambda self: self._parse_table_parts(),
     599        exp.TableAlias: lambda self: self._parse_table_alias(),
     600        exp.When: lambda self: seq_get(self._parse_when_matched(), 0),
     601        exp.Where: lambda self: self._parse_where(),
     602        exp.Window: lambda self: self._parse_named_window(),
     603        exp.With: lambda self: self._parse_with(),
     604        "JOIN_TYPE": lambda self: self._parse_join_parts(),
     605    }
     606
     607    STATEMENT_PARSERS = {
     608        TokenType.ALTER: lambda self: self._parse_alter(),
     609        TokenType.BEGIN: lambda self: self._parse_transaction(),
     610        TokenType.CACHE: lambda self: self._parse_cache(),
     611        TokenType.COMMIT: lambda self: self._parse_commit_or_rollback(),
     612        TokenType.COMMENT: lambda self: self._parse_comment(),
     613        TokenType.CREATE: lambda self: self._parse_create(),
     614        TokenType.DELETE: lambda self: self._parse_delete(),
     615        TokenType.DESC: lambda self: self._parse_describe(),
     616        TokenType.DESCRIBE: lambda self: self._parse_describe(),
     617        TokenType.DROP: lambda self: self._parse_drop(),
     618        TokenType.INSERT: lambda self: self._parse_insert(),
     619        TokenType.KILL: lambda self: self._parse_kill(),
     620        TokenType.LOAD: lambda self: self._parse_load(),
     621        TokenType.MERGE: lambda self: self._parse_merge(),
     622        TokenType.PIVOT: lambda self: self._parse_simplified_pivot(),
     623        TokenType.PRAGMA: lambda self: self.expression(exp.Pragma, this=self._parse_expression()),
     624        TokenType.REFRESH: lambda self: self._parse_refresh(),
     625        TokenType.ROLLBACK: lambda self: self._parse_commit_or_rollback(),
     626        TokenType.SET: lambda self: self._parse_set(),
     627        TokenType.UNCACHE: lambda self: self._parse_uncache(),
     628        TokenType.UPDATE: lambda self: self._parse_update(),
     629        TokenType.USE: lambda self: self.expression(
     630            exp.Use,
     631            kind=self._match_texts(("ROLE", "WAREHOUSE", "DATABASE", "SCHEMA"))
     632            and exp.var(self._prev.text),
     633            this=self._parse_table(schema=False),
     634        ),
     635    }
     636
     637    UNARY_PARSERS = {
     638        TokenType.PLUS: lambda self: self._parse_unary(),  # Unary + is handled as a no-op
     639        TokenType.NOT: lambda self: self.expression(exp.Not, this=self._parse_equality()),
     640        TokenType.TILDA: lambda self: self.expression(exp.BitwiseNot, this=self._parse_unary()),
     641        TokenType.DASH: lambda self: self.expression(exp.Neg, this=self._parse_unary()),
     642    }
     643
     644    PRIMARY_PARSERS = {
     645        TokenType.STRING: lambda self, token: self.expression(
     646            exp.Literal, this=token.text, is_string=True
     647        ),
     648        TokenType.NUMBER: lambda self, token: self.expression(
     649            exp.Literal, this=token.text, is_string=False
     650        ),
     651        TokenType.STAR: lambda self, _: self.expression(
     652            exp.Star, **{"except": self._parse_except(), "replace": self._parse_replace()}
     653        ),
     654        TokenType.NULL: lambda self, _: self.expression(exp.Null),
     655        TokenType.TRUE: lambda self, _: self.expression(exp.Boolean, this=True),
     656        TokenType.FALSE: lambda self, _: self.expression(exp.Boolean, this=False),
     657        TokenType.BIT_STRING: lambda self, token: self.expression(exp.BitString, this=token.text),
     658        TokenType.HEX_STRING: lambda self, token: self.expression(exp.HexString, this=token.text),
     659        TokenType.BYTE_STRING: lambda self, token: self.expression(exp.ByteString, this=token.text),
     660        TokenType.INTRODUCER: lambda self, token: self._parse_introducer(token),
     661        TokenType.NATIONAL_STRING: lambda self, token: self.expression(
     662            exp.National, this=token.text
     663        ),
     664        TokenType.RAW_STRING: lambda self, token: self.expression(exp.RawString, this=token.text),
     665        TokenType.HEREDOC_STRING: lambda self, token: self.expression(
     666            exp.RawString, this=token.text
     667        ),
     668        TokenType.UNICODE_STRING: lambda self, token: self.expression(
     669            exp.UnicodeString,
     670            this=token.text,
     671            escape=self._match_text_seq("UESCAPE") and self._parse_string(),
     672        ),
     673        TokenType.SESSION_PARAMETER: lambda self, _: self._parse_session_parameter(),
     674    }
     675
     676    PLACEHOLDER_PARSERS = {
     677        TokenType.PLACEHOLDER: lambda self: self.expression(exp.Placeholder),
     678        TokenType.PARAMETER: lambda self: self._parse_parameter(),
     679        TokenType.COLON: lambda self: (
     680            self.expression(exp.Placeholder, this=self._prev.text)
     681            if self._match(TokenType.NUMBER) or self._match_set(self.ID_VAR_TOKENS)
     682            else None
     683        ),
     684    }
     685
     686    RANGE_PARSERS = {
     687        TokenType.BETWEEN: lambda self, this: self._parse_between(this),
     688        TokenType.GLOB: binary_range_parser(exp.Glob),
     689        TokenType.ILIKE: binary_range_parser(exp.ILike),
     690        TokenType.IN: lambda self, this: self._parse_in(this),
     691        TokenType.IRLIKE: binary_range_parser(exp.RegexpILike),
     692        TokenType.IS: lambda self, this: self._parse_is(this),
     693        TokenType.LIKE: binary_range_parser(exp.Like),
     694        TokenType.OVERLAPS: binary_range_parser(exp.Overlaps),
     695        TokenType.RLIKE: binary_range_parser(exp.RegexpLike),
     696        TokenType.SIMILAR_TO: binary_range_parser(exp.SimilarTo),
     697        TokenType.FOR: lambda self, this: self._parse_comprehension(this),
     698    }
     699
     700    PROPERTY_PARSERS: t.Dict[str, t.Callable] = {
     701        "ALGORITHM": lambda self: self._parse_property_assignment(exp.AlgorithmProperty),
     702        "AUTO": lambda self: self._parse_auto_property(),
     703        "AUTO_INCREMENT": lambda self: self._parse_property_assignment(exp.AutoIncrementProperty),
     704        "BLOCKCOMPRESSION": lambda self: self._parse_blockcompression(),
     705        "CHARSET": lambda self, **kwargs: self._parse_character_set(**kwargs),
     706        "CHARACTER SET": lambda self, **kwargs: self._parse_character_set(**kwargs),
     707        "CHECKSUM": lambda self: self._parse_checksum(),
     708        "CLUSTER BY": lambda self: self._parse_cluster(),
     709        "CLUSTERED": lambda self: self._parse_clustered_by(),
     710        "COLLATE": lambda self, **kwargs: self._parse_property_assignment(
     711            exp.CollateProperty, **kwargs
     712        ),
     713        "COMMENT": lambda self: self._parse_property_assignment(exp.SchemaCommentProperty),
     714        "CONTAINS": lambda self: self._parse_contains_property(),
     715        "COPY": lambda self: self._parse_copy_property(),
     716        "DATABLOCKSIZE": lambda self, **kwargs: self._parse_datablocksize(**kwargs),
     717        "DEFINER": lambda self: self._parse_definer(),
     718        "DETERMINISTIC": lambda self: self.expression(
     719            exp.StabilityProperty, this=exp.Literal.string("IMMUTABLE")
     720        ),
     721        "DISTKEY": lambda self: self._parse_distkey(),
     722        "DISTSTYLE": lambda self: self._parse_property_assignment(exp.DistStyleProperty),
     723        "ENGINE": lambda self: self._parse_property_assignment(exp.EngineProperty),
     724        "EXECUTE": lambda self: self._parse_property_assignment(exp.ExecuteAsProperty),
     725        "EXTERNAL": lambda self: self.expression(exp.ExternalProperty),
     726        "FALLBACK": lambda self, **kwargs: self._parse_fallback(**kwargs),
     727        "FORMAT": lambda self: self._parse_property_assignment(exp.FileFormatProperty),
     728        "FREESPACE": lambda self: self._parse_freespace(),
     729        "HEAP": lambda self: self.expression(exp.HeapProperty),
     730        "IMMUTABLE": lambda self: self.expression(
     731            exp.StabilityProperty, this=exp.Literal.string("IMMUTABLE")
     732        ),
     733        "INHERITS": lambda self: self.expression(
     734            exp.InheritsProperty, expressions=self._parse_wrapped_csv(self._parse_table)
     735        ),
     736        "INPUT": lambda self: self.expression(exp.InputModelProperty, this=self._parse_schema()),
     737        "JOURNAL": lambda self, **kwargs: self._parse_journal(**kwargs),
     738        "LANGUAGE": lambda self: self._parse_property_assignment(exp.LanguageProperty),
     739        "LAYOUT": lambda self: self._parse_dict_property(this="LAYOUT"),
     740        "LIFETIME": lambda self: self._parse_dict_range(this="LIFETIME"),
     741        "LIKE": lambda self: self._parse_create_like(),
     742        "LOCATION": lambda self: self._parse_property_assignment(exp.LocationProperty),
     743        "LOCK": lambda self: self._parse_locking(),
     744        "LOCKING": lambda self: self._parse_locking(),
     745        "LOG": lambda self, **kwargs: self._parse_log(**kwargs),
     746        "MATERIALIZED": lambda self: self.expression(exp.MaterializedProperty),
     747        "MERGEBLOCKRATIO": lambda self, **kwargs: self._parse_mergeblockratio(**kwargs),
     748        "MODIFIES": lambda self: self._parse_modifies_property(),
     749        "MULTISET": lambda self: self.expression(exp.SetProperty, multi=True),
     750        "NO": lambda self: self._parse_no_property(),
     751        "ON": lambda self: self._parse_on_property(),
     752        "ORDER BY": lambda self: self._parse_order(skip_order_token=True),
     753        "OUTPUT": lambda self: self.expression(exp.OutputModelProperty, this=self._parse_schema()),
     754        "PARTITION": lambda self: self._parse_partitioned_of(),
     755        "PARTITION BY": lambda self: self._parse_partitioned_by(),
     756        "PARTITIONED BY": lambda self: self._parse_partitioned_by(),
     757        "PARTITIONED_BY": lambda self: self._parse_partitioned_by(),
     758        "PRIMARY KEY": lambda self: self._parse_primary_key(in_props=True),
     759        "RANGE": lambda self: self._parse_dict_range(this="RANGE"),
     760        "READS": lambda self: self._parse_reads_property(),
     761        "REMOTE": lambda self: self._parse_remote_with_connection(),
     762        "RETURNS": lambda self: self._parse_returns(),
     763        "ROW": lambda self: self._parse_row(),
     764        "ROW_FORMAT": lambda self: self._parse_property_assignment(exp.RowFormatProperty),
     765        "SAMPLE": lambda self: self.expression(
     766            exp.SampleProperty, this=self._match_text_seq("BY") and self._parse_bitwise()
     767        ),
     768        "SET": lambda self: self.expression(exp.SetProperty, multi=False),
     769        "SETTINGS": lambda self: self.expression(
     770            exp.SettingsProperty, expressions=self._parse_csv(self._parse_set_item)
     771        ),
     772        "SORTKEY": lambda self: self._parse_sortkey(),
     773        "SOURCE": lambda self: self._parse_dict_property(this="SOURCE"),
     774        "STABLE": lambda self: self.expression(
     775            exp.StabilityProperty, this=exp.Literal.string("STABLE")
     776        ),
     777        "STORED": lambda self: self._parse_stored(),
     778        "SYSTEM_VERSIONING": lambda self: self._parse_system_versioning_property(),
     779        "TBLPROPERTIES": lambda self: self._parse_wrapped_csv(self._parse_property),
     780        "TEMP": lambda self: self.expression(exp.TemporaryProperty),
     781        "TEMPORARY": lambda self: self.expression(exp.TemporaryProperty),
     782        "TO": lambda self: self._parse_to_table(),
     783        "TRANSIENT": lambda self: self.expression(exp.TransientProperty),
     784        "TRANSFORM": lambda self: self.expression(
     785            exp.TransformModelProperty, expressions=self._parse_wrapped_csv(self._parse_expression)
     786        ),
     787        "TTL": lambda self: self._parse_ttl(),
     788        "USING": lambda self: self._parse_property_assignment(exp.FileFormatProperty),
     789        "VOLATILE": lambda self: self._parse_volatile_property(),
     790        "WITH": lambda self: self._parse_with_property(),
     791    }
     792
     793    CONSTRAINT_PARSERS = {
     794        "AUTOINCREMENT": lambda self: self._parse_auto_increment(),
     795        "AUTO_INCREMENT": lambda self: self._parse_auto_increment(),
     796        "CASESPECIFIC": lambda self: self.expression(exp.CaseSpecificColumnConstraint, not_=False),
     797        "CHARACTER SET": lambda self: self.expression(
     798            exp.CharacterSetColumnConstraint, this=self._parse_var_or_string()
     799        ),
     800        "CHECK": lambda self: self.expression(
     801            exp.CheckColumnConstraint, this=self._parse_wrapped(self._parse_conjunction)
     802        ),
     803        "COLLATE": lambda self: self.expression(
     804            exp.CollateColumnConstraint, this=self._parse_var()
     805        ),
     806        "COMMENT": lambda self: self.expression(
     807            exp.CommentColumnConstraint, this=self._parse_string()
     808        ),
     809        "COMPRESS": lambda self: self._parse_compress(),
     810        "CLUSTERED": lambda self: self.expression(
     811            exp.ClusteredColumnConstraint, this=self._parse_wrapped_csv(self._parse_ordered)
     812        ),
     813        "NONCLUSTERED": lambda self: self.expression(
     814            exp.NonClusteredColumnConstraint, this=self._parse_wrapped_csv(self._parse_ordered)
     815        ),
     816        "DEFAULT": lambda self: self.expression(
     817            exp.DefaultColumnConstraint, this=self._parse_bitwise()
     818        ),
     819        "ENCODE": lambda self: self.expression(exp.EncodeColumnConstraint, this=self._parse_var()),
     820        "FOREIGN KEY": lambda self: self._parse_foreign_key(),
     821        "FORMAT": lambda self: self.expression(
     822            exp.DateFormatColumnConstraint, this=self._parse_var_or_string()
     823        ),
     824        "GENERATED": lambda self: self._parse_generated_as_identity(),
     825        "IDENTITY": lambda self: self._parse_auto_increment(),
     826        "INLINE": lambda self: self._parse_inline(),
     827        "LIKE": lambda self: self._parse_create_like(),
     828        "NOT": lambda self: self._parse_not_constraint(),
     829        "NULL": lambda self: self.expression(exp.NotNullColumnConstraint, allow_null=True),
     830        "ON": lambda self: (
     831            self._match(TokenType.UPDATE)
     832            and self.expression(exp.OnUpdateColumnConstraint, this=self._parse_function())
     833        )
     834        or self.expression(exp.OnProperty, this=self._parse_id_var()),
     835        "PATH": lambda self: self.expression(exp.PathColumnConstraint, this=self._parse_string()),
     836        "PERIOD": lambda self: self._parse_period_for_system_time(),
     837        "PRIMARY KEY": lambda self: self._parse_primary_key(),
     838        "REFERENCES": lambda self: self._parse_references(match=False),
     839        "TITLE": lambda self: self.expression(
     840            exp.TitleColumnConstraint, this=self._parse_var_or_string()
     841        ),
     842        "TTL": lambda self: self.expression(exp.MergeTreeTTL, expressions=[self._parse_bitwise()]),
     843        "UNIQUE": lambda self: self._parse_unique(),
     844        "UPPERCASE": lambda self: self.expression(exp.UppercaseColumnConstraint),
     845        "WITH": lambda self: self.expression(
     846            exp.Properties, expressions=self._parse_wrapped_csv(self._parse_property)
     847        ),
     848    }
     849
     850    ALTER_PARSERS = {
     851        "ADD": lambda self: self._parse_alter_table_add(),
     852        "ALTER": lambda self: self._parse_alter_table_alter(),
     853        "CLUSTER BY": lambda self: self._parse_cluster(wrapped=True),
     854        "DELETE": lambda self: self.expression(exp.Delete, where=self._parse_where()),
     855        "DROP": lambda self: self._parse_alter_table_drop(),
     856        "RENAME": lambda self: self._parse_alter_table_rename(),
     857    }
     858
     859    SCHEMA_UNNAMED_CONSTRAINTS = {"CHECK", "FOREIGN KEY", "LIKE", "PRIMARY KEY", "UNIQUE", "PERIOD"}
     860
     861    NO_PAREN_FUNCTION_PARSERS = {
     862        "ANY": lambda self: self.expression(exp.Any, this=self._parse_bitwise()),
     863        "CASE": lambda self: self._parse_case(),
     864        "IF": lambda self: self._parse_if(),
     865        "NEXT": lambda self: self._parse_next_value_for(),
     866    }
     867
     868    INVALID_FUNC_NAME_TOKENS = {
     869        TokenType.IDENTIFIER,
     870        TokenType.STRING,
     871    }
     872
     873    FUNCTIONS_WITH_ALIASED_ARGS = {"STRUCT"}
     874
     875    FUNCTION_PARSERS = {
     876        "ANY_VALUE": lambda self: self._parse_any_value(),
     877        "CAST": lambda self: self._parse_cast(self.STRICT_CAST),
     878        "CONVERT": lambda self: self._parse_convert(self.STRICT_CAST),
     879        "DECODE": lambda self: self._parse_decode(),
     880        "EXTRACT": lambda self: self._parse_extract(),
     881        "JSON_OBJECT": lambda self: self._parse_json_object(),
     882        "JSON_OBJECTAGG": lambda self: self._parse_json_object(agg=True),
     883        "JSON_TABLE": lambda self: self._parse_json_table(),
     884        "MATCH": lambda self: self._parse_match_against(),
     885        "OPENJSON": lambda self: self._parse_open_json(),
     886        "POSITION": lambda self: self._parse_position(),
     887        "PREDICT": lambda self: self._parse_predict(),
     888        "SAFE_CAST": lambda self: self._parse_cast(False, safe=True),
     889        "STRING_AGG": lambda self: self._parse_string_agg(),
     890        "SUBSTRING": lambda self: self._parse_substring(),
     891        "TRIM": lambda self: self._parse_trim(),
     892        "TRY_CAST": lambda self: self._parse_cast(False, safe=True),
     893        "TRY_CONVERT": lambda self: self._parse_convert(False, safe=True),
     894    }
     895
     896    QUERY_MODIFIER_PARSERS = {
     897        TokenType.MATCH_RECOGNIZE: lambda self: ("match", self._parse_match_recognize()),
     898        TokenType.WHERE: lambda self: ("where", self._parse_where()),
     899        TokenType.GROUP_BY: lambda self: ("group", self._parse_group()),
     900        TokenType.HAVING: lambda self: ("having", self._parse_having()),
     901        TokenType.QUALIFY: lambda self: ("qualify", self._parse_qualify()),
     902        TokenType.WINDOW: lambda self: ("windows", self._parse_window_clause()),
     903        TokenType.ORDER_BY: lambda self: ("order", self._parse_order()),
     904        TokenType.LIMIT: lambda self: ("limit", self._parse_limit()),
     905        TokenType.FETCH: lambda self: ("limit", self._parse_limit()),
     906        TokenType.OFFSET: lambda self: ("offset", self._parse_offset()),
     907        TokenType.FOR: lambda self: ("locks", self._parse_locks()),
     908        TokenType.LOCK: lambda self: ("locks", self._parse_locks()),
     909        TokenType.TABLE_SAMPLE: lambda self: ("sample", self._parse_table_sample(as_modifier=True)),
     910        TokenType.USING: lambda self: ("sample", self._parse_table_sample(as_modifier=True)),
     911        TokenType.CLUSTER_BY: lambda self: (
     912            "cluster",
     913            self._parse_sort(exp.Cluster, TokenType.CLUSTER_BY),
     914        ),
     915        TokenType.DISTRIBUTE_BY: lambda self: (
     916            "distribute",
     917            self._parse_sort(exp.Distribute, TokenType.DISTRIBUTE_BY),
     918        ),
     919        TokenType.SORT_BY: lambda self: ("sort", self._parse_sort(exp.Sort, TokenType.SORT_BY)),
     920        TokenType.CONNECT_BY: lambda self: ("connect", self._parse_connect(skip_start_token=True)),
     921        TokenType.START_WITH: lambda self: ("connect", self._parse_connect()),
     922    }
     923
     924    SET_PARSERS = {
     925        "GLOBAL": lambda self: self._parse_set_item_assignment("GLOBAL"),
     926        "LOCAL": lambda self: self._parse_set_item_assignment("LOCAL"),
     927        "SESSION": lambda self: self._parse_set_item_assignment("SESSION"),
     928        "TRANSACTION": lambda self: self._parse_set_transaction(),
     929    }
     930
     931    SHOW_PARSERS: t.Dict[str, t.Callable] = {}
     932
     933    TYPE_LITERAL_PARSERS = {
     934        exp.DataType.Type.JSON: lambda self, this, _: self.expression(exp.ParseJSON, this=this),
     935    }
     936
     937    MODIFIABLES = (exp.Subquery, exp.Subqueryable, exp.Table)
     938
     939    DDL_SELECT_TOKENS = {TokenType.SELECT, TokenType.WITH, TokenType.L_PAREN}
     940
     941    PRE_VOLATILE_TOKENS = {TokenType.CREATE, TokenType.REPLACE, TokenType.UNIQUE}
     942
     943    TRANSACTION_KIND = {"DEFERRED", "IMMEDIATE", "EXCLUSIVE"}
     944    TRANSACTION_CHARACTERISTICS = {
     945        "ISOLATION LEVEL REPEATABLE READ",
     946        "ISOLATION LEVEL READ COMMITTED",
     947        "ISOLATION LEVEL READ UNCOMMITTED",
     948        "ISOLATION LEVEL SERIALIZABLE",
     949        "READ WRITE",
     950        "READ ONLY",
     951    }
     952
     953    INSERT_ALTERNATIVES = {"ABORT", "FAIL", "IGNORE", "REPLACE", "ROLLBACK"}
     954
     955    CLONE_KEYWORDS = {"CLONE", "COPY"}
     956    HISTORICAL_DATA_KIND = {"TIMESTAMP", "OFFSET", "STATEMENT", "STREAM"}
     957
     958    OPCLASS_FOLLOW_KEYWORDS = {"ASC", "DESC", "NULLS"}
     959    OPTYPE_FOLLOW_TOKENS = {TokenType.COMMA, TokenType.R_PAREN}
     960
     961    TABLE_INDEX_HINT_TOKENS = {TokenType.FORCE, TokenType.IGNORE, TokenType.USE}
     962
     963    WINDOW_ALIAS_TOKENS = ID_VAR_TOKENS - {TokenType.ROWS}
     964    WINDOW_BEFORE_PAREN_TOKENS = {TokenType.OVER}
     965    WINDOW_SIDES = {"FOLLOWING", "PRECEDING"}
     966
     967    JSON_KEY_VALUE_SEPARATOR_TOKENS = {TokenType.COLON, TokenType.COMMA, TokenType.IS}
     968
     969    FETCH_TOKENS = ID_VAR_TOKENS - {TokenType.ROW, TokenType.ROWS, TokenType.PERCENT}
     970
     971    ADD_CONSTRAINT_TOKENS = {TokenType.CONSTRAINT, TokenType.PRIMARY_KEY, TokenType.FOREIGN_KEY}
     972
     973    DISTINCT_TOKENS = {TokenType.DISTINCT}
     974
     975    NULL_TOKENS = {TokenType.NULL}
     976
     977    UNNEST_OFFSET_ALIAS_TOKENS = ID_VAR_TOKENS - SET_OPERATIONS
     978
     979    STRICT_CAST = True
     980
     981    PREFIXED_PIVOT_COLUMNS = False
     982    IDENTIFY_PIVOT_STRINGS = False
     983
     984    LOG_DEFAULTS_TO_LN = False
     985
     986    # Whether or not ADD is present for each column added by ALTER TABLE
     987    ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN = True
     988
     989    # Whether or not the table sample clause expects CSV syntax
     990    TABLESAMPLE_CSV = False
     991
     992    # Whether or not the SET command needs a delimiter (e.g. "=") for assignments
     993    SET_REQUIRES_ASSIGNMENT_DELIMITER = True
     994
     995    # Whether the TRIM function expects the characters to trim as its first argument
     996    TRIM_PATTERN_FIRST = False
     997
     998    # Whether or not string aliases are supported `SELECT COUNT(*) 'count'`
     999    STRING_ALIASES = False
    1000
    1001    # Whether query modifiers such as LIMIT are attached to the UNION node (vs its right operand)
    1002    MODIFIERS_ATTACHED_TO_UNION = True
    1003    UNION_MODIFIERS = {"order", "limit", "offset"}
    1004
    1005    # parses no parenthesis if statements as commands
    1006    NO_PAREN_IF_COMMANDS = True
    1007
    1008    __slots__ = (
    1009        "error_level",
    1010        "error_message_context",
    1011        "max_errors",
    1012        "dialect",
    1013        "sql",
    1014        "errors",
    1015        "_tokens",
    1016        "_index",
    1017        "_curr",
    1018        "_next",
    1019        "_prev",
    1020        "_prev_comments",
    1021    )
    1022
    1023    # Autofilled
    1024    SHOW_TRIE: t.Dict = {}
    1025    SET_TRIE: t.Dict = {}
    1026
    1027    def __init__(
    1028        self,
    1029        error_level: t.Optional[ErrorLevel] = None,
    1030        error_message_context: int = 100,
    1031        max_errors: int = 3,
    1032        dialect: DialectType = None,
    1033    ):
    1034        from sqlglot.dialects import Dialect
    1035
    1036        self.error_level = error_level or ErrorLevel.IMMEDIATE
    1037        self.error_message_context = error_message_context
    1038        self.max_errors = max_errors
    1039        self.dialect = Dialect.get_or_raise(dialect)
    1040        self.reset()
    1041
    1042    def reset(self):
    1043        self.sql = ""
    1044        self.errors = []
    1045        self._tokens = []
    1046        self._index = 0
    1047        self._curr = None
    1048        self._next = None
    1049        self._prev = None
    1050        self._prev_comments = None
    1051
    1052    def parse(
    1053        self, raw_tokens: t.List[Token], sql: t.Optional[str] = None
    1054    ) -> t.List[t.Optional[exp.Expression]]:
    1055        """
    1056        Parses a list of tokens and returns a list of syntax trees, one tree
    1057        per parsed SQL statement.
    1058
    1059        Args:
    1060            raw_tokens: The list of tokens.
    1061            sql: The original SQL string, used to produce helpful debug messages.
    1062
    1063        Returns:
    1064            The list of the produced syntax trees.
    1065        """
    1066        return self._parse(
    1067            parse_method=self.__class__._parse_statement, raw_tokens=raw_tokens, sql=sql
    1068        )
    1069
    1070    def parse_into(
    1071        self,
    1072        expression_types: exp.IntoType,
    1073        raw_tokens: t.List[Token],
    1074        sql: t.Optional[str] = None,
    1075    ) -> t.List[t.Optional[exp.Expression]]:
    1076        """
    1077        Parses a list of tokens into a given Expression type. If a collection of Expression
    1078        types is given instead, this method will try to parse the token list into each one
    1079        of them, stopping at the first for which the parsing succeeds.
    1080
    1081        Args:
    1082            expression_types: The expression type(s) to try and parse the token list into.
    1083            raw_tokens: The list of tokens.
    1084            sql: The original SQL string, used to produce helpful debug messages.
    1085
    1086        Returns:
    1087            The target Expression.
    1088        """
    1089        errors = []
    1090        for expression_type in ensure_list(expression_types):
    1091            parser = self.EXPRESSION_PARSERS.get(expression_type)
    1092            if not parser:
    1093                raise TypeError(f"No parser registered for {expression_type}")
    1094
    1095            try:
    1096                return self._parse(parser, raw_tokens, sql)
    1097            except ParseError as e:
    1098                e.errors[0]["into_expression"] = expression_type
    1099                errors.append(e)
    1100
    1101        raise ParseError(
    1102            f"Failed to parse '{sql or raw_tokens}' into {expression_types}",
    1103            errors=merge_errors(errors),
    1104        ) from errors[-1]
    1105
    1106    def _parse(
    1107        self,
    1108        parse_method: t.Callable[[Parser], t.Optional[exp.Expression]],
    1109        raw_tokens: t.List[Token],
    1110        sql: t.Optional[str] = None,
    1111    ) -> t.List[t.Optional[exp.Expression]]:
    1112        self.reset()
    1113        self.sql = sql or ""
    1114
    1115        total = len(raw_tokens)
    1116        chunks: t.List[t.List[Token]] = [[]]
    1117
    1118        for i, token in enumerate(raw_tokens):
    1119            if token.token_type == TokenType.SEMICOLON:
    1120                if i < total - 1:
    1121                    chunks.append([])
    1122            else:
    1123                chunks[-1].append(token)
    1124
    1125        expressions = []
    1126
    1127        for tokens in chunks:
    1128            self._index = -1
    1129            self._tokens = tokens
    1130            self._advance()
    1131
    1132            expressions.append(parse_method(self))
    1133
    1134            if self._index < len(self._tokens):
    1135                self.raise_error("Invalid expression / Unexpected token")
    1136
    1137            self.check_errors()
    1138
    1139        return expressions
    1140
    1141    def check_errors(self) -> None:
    1142        """Logs or raises any found errors, depending on the chosen error level setting."""
    1143        if self.error_level == ErrorLevel.WARN:
    1144            for error in self.errors:
    1145                logger.error(str(error))
    1146        elif self.error_level == ErrorLevel.RAISE and self.errors:
    1147            raise ParseError(
    1148                concat_messages(self.errors, self.max_errors),
    1149                errors=merge_errors(self.errors),
    1150            )
    1151
    1152    def raise_error(self, message: str, token: t.Optional[Token] = None) -> None:
    1153        """
    1154        Appends an error in the list of recorded errors or raises it, depending on the chosen
    1155        error level setting.
    1156        """
    1157        token = token or self._curr or self._prev or Token.string("")
    1158        start = token.start
    1159        end = token.end + 1
    1160        start_context = self.sql[max(start - self.error_message_context, 0) : start]
    1161        highlight = self.sql[start:end]
    1162        end_context = self.sql[end : end + self.error_message_context]
    1163
    1164        error = ParseError.new(
    1165            f"{message}. Line {token.line}, Col: {token.col}.\n"
    1166            f"  {start_context}\033[4m{highlight}\033[0m{end_context}",
    1167            description=message,
    1168            line=token.line,
    1169            col=token.col,
    1170            start_context=start_context,
    1171            highlight=highlight,
    1172            end_context=end_context,
    1173        )
    1174
    1175        if self.error_level == ErrorLevel.IMMEDIATE:
    1176            raise error
    1177
    1178        self.errors.append(error)
    1179
    1180    def expression(
    1181        self, exp_class: t.Type[E], comments: t.Optional[t.List[str]] = None, **kwargs
    1182    ) -> E:
    1183        """
    1184        Creates a new, validated Expression.
    1185
    1186        Args:
    1187            exp_class: The expression class to instantiate.
    1188            comments: An optional list of comments to attach to the expression.
    1189            kwargs: The arguments to set for the expression along with their respective values.
    1190
    1191        Returns:
    1192            The target expression.
    1193        """
    1194        instance = exp_class(**kwargs)
    1195        instance.add_comments(comments) if comments else self._add_comments(instance)
    1196        return self.validate_expression(instance)
    1197
    1198    def _add_comments(self, expression: t.Optional[exp.Expression]) -> None:
    1199        if expression and self._prev_comments:
    1200            expression.add_comments(self._prev_comments)
    1201            self._prev_comments = None
    1202
    1203    def validate_expression(self, expression: E, args: t.Optional[t.List] = None) -> E:
    1204        """
    1205        Validates an Expression, making sure that all its mandatory arguments are set.
    1206
    1207        Args:
    1208            expression: The expression to validate.
    1209            args: An optional list of items that was used to instantiate the expression, if it's a Func.
    1210
    1211        Returns:
    1212            The validated expression.
    1213        """
    1214        if self.error_level != ErrorLevel.IGNORE:
    1215            for error_message in expression.error_messages(args):
    1216                self.raise_error(error_message)
    1217
    1218        return expression
    1219
    1220    def _find_sql(self, start: Token, end: Token) -> str:
    1221        return self.sql[start.start : end.end + 1]
    1222
    1223    def _is_connected(self) -> bool:
    1224        return self._prev and self._curr and self._prev.end + 1 == self._curr.start
    1225
    1226    def _advance(self, times: int = 1) -> None:
    1227        self._index += times
    1228        self._curr = seq_get(self._tokens, self._index)
    1229        self._next = seq_get(self._tokens, self._index + 1)
    1230
    1231        if self._index > 0:
    1232            self._prev = self._tokens[self._index - 1]
    1233            self._prev_comments = self._prev.comments
    1234        else:
    1235            self._prev = None
    1236            self._prev_comments = None
    1237
    1238    def _retreat(self, index: int) -> None:
    1239        if index != self._index:
    1240            self._advance(index - self._index)
    1241
    1242    def _warn_unsupported(self) -> None:
    1243        if len(self._tokens) <= 1:
    1244            return
    1245
    1246        # We use _find_sql because self.sql may comprise multiple chunks, and we're only
    1247        # interested in emitting a warning for the one being currently processed.
    1248        sql = self._find_sql(self._tokens[0], self._tokens[-1])[: self.error_message_context]
    1249
    1250        logger.warning(
    1251            f"'{sql}' contains unsupported syntax. Falling back to parsing as a 'Command'."
    1252        )
    1253
    1254    def _parse_command(self) -> exp.Command:
    1255        self._warn_unsupported()
    1256        return self.expression(
    1257            exp.Command, this=self._prev.text.upper(), expression=self._parse_string()
    1258        )
    1259
    1260    def _parse_comment(self, allow_exists: bool = True) -> exp.Expression:
    1261        start = self._prev
    1262        exists = self._parse_exists() if allow_exists else None
    1263
    1264        self._match(TokenType.ON)
    1265
    1266        kind = self._match_set(self.CREATABLES) and self._prev
    1267        if not kind:
    1268            return self._parse_as_command(start)
    1269
    1270        if kind.token_type in (TokenType.FUNCTION, TokenType.PROCEDURE):
    1271            this = self._parse_user_defined_function(kind=kind.token_type)
    1272        elif kind.token_type == TokenType.TABLE:
    1273            this = self._parse_table(alias_tokens=self.COMMENT_TABLE_ALIAS_TOKENS)
    1274        elif kind.token_type == TokenType.COLUMN:
    1275            this = self._parse_column()
    1276        else:
    1277            this = self._parse_id_var()
    1278
    1279        self._match(TokenType.IS)
    1280
    1281        return self.expression(
    1282            exp.Comment, this=this, kind=kind.text, expression=self._parse_string(), exists=exists
    1283        )
    1284
    1285    def _parse_to_table(
    1286        self,
    1287    ) -> exp.ToTableProperty:
    1288        table = self._parse_table_parts(schema=True)
    1289        return self.expression(exp.ToTableProperty, this=table)
    1290
    1291    # https://clickhouse.com/docs/en/engines/table-engines/mergetree-family/mergetree#mergetree-table-ttl
    1292    def _parse_ttl(self) -> exp.Expression:
    1293        def _parse_ttl_action() -> t.Optional[exp.Expression]:
    1294            this = self._parse_bitwise()
    1295
    1296            if self._match_text_seq("DELETE"):
    1297                return self.expression(exp.MergeTreeTTLAction, this=this, delete=True)
    1298            if self._match_text_seq("RECOMPRESS"):
    1299                return self.expression(
    1300                    exp.MergeTreeTTLAction, this=this, recompress=self._parse_bitwise()
    1301                )
    1302            if self._match_text_seq("TO", "DISK"):
    1303                return self.expression(
    1304                    exp.MergeTreeTTLAction, this=this, to_disk=self._parse_string()
    1305                )
    1306            if self._match_text_seq("TO", "VOLUME"):
    1307                return self.expression(
    1308                    exp.MergeTreeTTLAction, this=this, to_volume=self._parse_string()
    1309                )
    1310
    1311            return this
    1312
    1313        expressions = self._parse_csv(_parse_ttl_action)
    1314        where = self._parse_where()
    1315        group = self._parse_group()
    1316
    1317        aggregates = None
    1318        if group and self._match(TokenType.SET):
    1319            aggregates = self._parse_csv(self._parse_set_item)
    1320
    1321        return self.expression(
    1322            exp.MergeTreeTTL,
    1323            expressions=expressions,
    1324            where=where,
    1325            group=group,
    1326            aggregates=aggregates,
    1327        )
    1328
    1329    def _parse_statement(self) -> t.Optional[exp.Expression]:
    1330        if self._curr is None:
    1331            return None
    1332
    1333        if self._match_set(self.STATEMENT_PARSERS):
    1334            return self.STATEMENT_PARSERS[self._prev.token_type](self)
    1335
    1336        if self._match_set(Tokenizer.COMMANDS):
    1337            return self._parse_command()
    1338
    1339        expression = self._parse_expression()
    1340        expression = self._parse_set_operations(expression) if expression else self._parse_select()
    1341        return self._parse_query_modifiers(expression)
    1342
    1343    def _parse_drop(self, exists: bool = False) -> exp.Drop | exp.Command:
    1344        start = self._prev
    1345        temporary = self._match(TokenType.TEMPORARY)
    1346        materialized = self._match_text_seq("MATERIALIZED")
    1347
    1348        kind = self._match_set(self.CREATABLES) and self._prev.text
    1349        if not kind:
    1350            return self._parse_as_command(start)
    1351
    1352        return self.expression(
    1353            exp.Drop,
    1354            comments=start.comments,
    1355            exists=exists or self._parse_exists(),
    1356            this=self._parse_table(
    1357                schema=True, is_db_reference=self._prev.token_type == TokenType.SCHEMA
    1358            ),
    1359            kind=kind,
    1360            temporary=temporary,
    1361            materialized=materialized,
    1362            cascade=self._match_text_seq("CASCADE"),
    1363            constraints=self._match_text_seq("CONSTRAINTS"),
    1364            purge=self._match_text_seq("PURGE"),
    1365        )
    1366
    1367    def _parse_exists(self, not_: bool = False) -> t.Optional[bool]:
    1368        return (
    1369            self._match_text_seq("IF")
    1370            and (not not_ or self._match(TokenType.NOT))
    1371            and self._match(TokenType.EXISTS)
    1372        )
    1373
    1374    def _parse_create(self) -> exp.Create | exp.Command:
    1375        # Note: this can't be None because we've matched a statement parser
    1376        start = self._prev
    1377        comments = self._prev_comments
    1378
    1379        replace = (
    1380            start.token_type == TokenType.REPLACE
    1381            or self._match_pair(TokenType.OR, TokenType.REPLACE)
    1382            or self._match_pair(TokenType.OR, TokenType.ALTER)
    1383        )
    1384        unique = self._match(TokenType.UNIQUE)
    1385
    1386        if self._match_pair(TokenType.TABLE, TokenType.FUNCTION, advance=False):
    1387            self._advance()
    1388
    1389        properties = None
    1390        create_token = self._match_set(self.CREATABLES) and self._prev
    1391
    1392        if not create_token:
    1393            # exp.Properties.Location.POST_CREATE
    1394            properties = self._parse_properties()
    1395            create_token = self._match_set(self.CREATABLES) and self._prev
    1396
    1397            if not properties or not create_token:
    1398                return self._parse_as_command(start)
    1399
    1400        exists = self._parse_exists(not_=True)
    1401        this = None
    1402        expression: t.Optional[exp.Expression] = None
    1403        indexes = None
    1404        no_schema_binding = None
    1405        begin = None
    1406        end = None
    1407        clone = None
    1408
    1409        def extend_props(temp_props: t.Optional[exp.Properties]) -> None:
    1410            nonlocal properties
    1411            if properties and temp_props:
    1412                properties.expressions.extend(temp_props.expressions)
    1413            elif temp_props:
    1414                properties = temp_props
    1415
    1416        if create_token.token_type in (TokenType.FUNCTION, TokenType.PROCEDURE):
    1417            this = self._parse_user_defined_function(kind=create_token.token_type)
    1418
    1419            # exp.Properties.Location.POST_SCHEMA ("schema" here is the UDF's type signature)
    1420            extend_props(self._parse_properties())
    1421
    1422            expression = self._match(TokenType.ALIAS) and self._parse_heredoc()
    1423
    1424            if not expression:
    1425                if self._match(TokenType.COMMAND):
    1426                    expression = self._parse_as_command(self._prev)
    1427                else:
    1428                    begin = self._match(TokenType.BEGIN)
    1429                    return_ = self._match_text_seq("RETURN")
    1430
    1431                    if self._match(TokenType.STRING, advance=False):
    1432                        # Takes care of BigQuery's JavaScript UDF definitions that end in an OPTIONS property
    1433                        # # https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_function_statement
    1434                        expression = self._parse_string()
    1435                        extend_props(self._parse_properties())
    1436                    else:
    1437                        expression = self._parse_statement()
    1438
    1439                    end = self._match_text_seq("END")
    1440
    1441                    if return_:
    1442                        expression = self.expression(exp.Return, this=expression)
    1443        elif create_token.token_type == TokenType.INDEX:
    1444            this = self._parse_index(index=self._parse_id_var())
    1445        elif create_token.token_type in self.DB_CREATABLES:
    1446            table_parts = self._parse_table_parts(
    1447                schema=True, is_db_reference=create_token.token_type == TokenType.SCHEMA
    1448            )
    1449
    1450            # exp.Properties.Location.POST_NAME
    1451            self._match(TokenType.COMMA)
    1452            extend_props(self._parse_properties(before=True))
    1453
    1454            this = self._parse_schema(this=table_parts)
    1455
    1456            # exp.Properties.Location.POST_SCHEMA and POST_WITH
    1457            extend_props(self._parse_properties())
    1458
    1459            self._match(TokenType.ALIAS)
    1460            if not self._match_set(self.DDL_SELECT_TOKENS, advance=False):
    1461                # exp.Properties.Location.POST_ALIAS
    1462                extend_props(self._parse_properties())
    1463
    1464            expression = self._parse_ddl_select()
    1465
    1466            if create_token.token_type == TokenType.TABLE:
    1467                # exp.Properties.Location.POST_EXPRESSION
    1468                extend_props(self._parse_properties())
    1469
    1470                indexes = []
    1471                while True:
    1472                    index = self._parse_index()
    1473
    1474                    # exp.Properties.Location.POST_INDEX
    1475                    extend_props(self._parse_properties())
    1476
    1477                    if not index:
    1478                        break
    1479                    else:
    1480                        self._match(TokenType.COMMA)
    1481                        indexes.append(index)
    1482            elif create_token.token_type == TokenType.VIEW:
    1483                if self._match_text_seq("WITH", "NO", "SCHEMA", "BINDING"):
    1484                    no_schema_binding = True
    1485
    1486            shallow = self._match_text_seq("SHALLOW")
    1487
    1488            if self._match_texts(self.CLONE_KEYWORDS):
    1489                copy = self._prev.text.lower() == "copy"
    1490                clone = self.expression(
    1491                    exp.Clone, this=self._parse_table(schema=True), shallow=shallow, copy=copy
    1492                )
    1493
    1494        if self._curr:
    1495            return self._parse_as_command(start)
    1496
    1497        return self.expression(
    1498            exp.Create,
    1499            comments=comments,
    1500            this=this,
    1501            kind=create_token.text.upper(),
    1502            replace=replace,
    1503            unique=unique,
    1504            expression=expression,
    1505            exists=exists,
    1506            properties=properties,
    1507            indexes=indexes,
    1508            no_schema_binding=no_schema_binding,
    1509            begin=begin,
    1510            end=end,
    1511            clone=clone,
    1512        )
    1513
    1514    def _parse_property_before(self) -> t.Optional[exp.Expression]:
    1515        # only used for teradata currently
    1516        self._match(TokenType.COMMA)
    1517
    1518        kwargs = {
    1519            "no": self._match_text_seq("NO"),
    1520            "dual": self._match_text_seq("DUAL"),
    1521            "before": self._match_text_seq("BEFORE"),
    1522            "default": self._match_text_seq("DEFAULT"),
    1523            "local": (self._match_text_seq("LOCAL") and "LOCAL")
    1524            or (self._match_text_seq("NOT", "LOCAL") and "NOT LOCAL"),
    1525            "after": self._match_text_seq("AFTER"),
    1526            "minimum": self._match_texts(("MIN", "MINIMUM")),
    1527            "maximum": self._match_texts(("MAX", "MAXIMUM")),
    1528        }
    1529
    1530        if self._match_texts(self.PROPERTY_PARSERS):
    1531            parser = self.PROPERTY_PARSERS[self._prev.text.upper()]
    1532            try:
    1533                return parser(self, **{k: v for k, v in kwargs.items() if v})
    1534            except TypeError:
    1535                self.raise_error(f"Cannot parse property '{self._prev.text}'")
    1536
    1537        return None
    1538
    1539    def _parse_property(self) -> t.Optional[exp.Expression]:
    1540        if self._match_texts(self.PROPERTY_PARSERS):
    1541            return self.PROPERTY_PARSERS[self._prev.text.upper()](self)
    1542
    1543        if self._match(TokenType.DEFAULT) and self._match_texts(self.PROPERTY_PARSERS):
    1544            return self.PROPERTY_PARSERS[self._prev.text.upper()](self, default=True)
    1545
    1546        if self._match_text_seq("COMPOUND", "SORTKEY"):
    1547            return self._parse_sortkey(compound=True)
    1548
    1549        if self._match_text_seq("SQL", "SECURITY"):
    1550            return self.expression(exp.SqlSecurityProperty, definer=self._match_text_seq("DEFINER"))
    1551
    1552        index = self._index
    1553        key = self._parse_column()
    1554
    1555        if not self._match(TokenType.EQ):
    1556            self._retreat(index)
    1557            return None
    1558
    1559        return self.expression(
    1560            exp.Property,
    1561            this=key.to_dot() if isinstance(key, exp.Column) else key,
    1562            value=self._parse_column() or self._parse_var(any_token=True),
    1563        )
    1564
    1565    def _parse_stored(self) -> exp.FileFormatProperty:
    1566        self._match(TokenType.ALIAS)
    1567
    1568        input_format = self._parse_string() if self._match_text_seq("INPUTFORMAT") else None
    1569        output_format = self._parse_string() if self._match_text_seq("OUTPUTFORMAT") else None
    1570
    1571        return self.expression(
    1572            exp.FileFormatProperty,
    1573            this=(
    1574                self.expression(
    1575                    exp.InputOutputFormat, input_format=input_format, output_format=output_format
    1576                )
    1577                if input_format or output_format
    1578                else self._parse_var_or_string() or self._parse_number() or self._parse_id_var()
    1579            ),
    1580        )
    1581
    1582    def _parse_property_assignment(self, exp_class: t.Type[E], **kwargs: t.Any) -> E:
    1583        self._match(TokenType.EQ)
    1584        self._match(TokenType.ALIAS)
    1585        return self.expression(exp_class, this=self._parse_field(), **kwargs)
    1586
    1587    def _parse_properties(self, before: t.Optional[bool] = None) -> t.Optional[exp.Properties]:
    1588        properties = []
    1589        while True:
    1590            if before:
    1591                prop = self._parse_property_before()
    1592            else:
    1593                prop = self._parse_property()
    1594
    1595            if not prop:
    1596                break
    1597            for p in ensure_list(prop):
    1598                properties.append(p)
    1599
    1600        if properties:
    1601            return self.expression(exp.Properties, expressions=properties)
    1602
    1603        return None
    1604
    1605    def _parse_fallback(self, no: bool = False) -> exp.FallbackProperty:
    1606        return self.expression(
    1607            exp.FallbackProperty, no=no, protection=self._match_text_seq("PROTECTION")
    1608        )
    1609
    1610    def _parse_volatile_property(self) -> exp.VolatileProperty | exp.StabilityProperty:
    1611        if self._index >= 2:
    1612            pre_volatile_token = self._tokens[self._index - 2]
    1613        else:
    1614            pre_volatile_token = None
    1615
    1616        if pre_volatile_token and pre_volatile_token.token_type in self.PRE_VOLATILE_TOKENS:
    1617            return exp.VolatileProperty()
    1618
    1619        return self.expression(exp.StabilityProperty, this=exp.Literal.string("VOLATILE"))
    1620
    1621    def _parse_system_versioning_property(self) -> exp.WithSystemVersioningProperty:
    1622        self._match_pair(TokenType.EQ, TokenType.ON)
    1623
    1624        prop = self.expression(exp.WithSystemVersioningProperty)
    1625        if self._match(TokenType.L_PAREN):
    1626            self._match_text_seq("HISTORY_TABLE", "=")
    1627            prop.set("this", self._parse_table_parts())
    1628
    1629            if self._match(TokenType.COMMA):
    1630                self._match_text_seq("DATA_CONSISTENCY_CHECK", "=")
    1631                prop.set("expression", self._advance_any() and self._prev.text.upper())
    1632
    1633            self._match_r_paren()
    1634
    1635        return prop
    1636
    1637    def _parse_with_property(
    1638        self,
    1639    ) -> t.Optional[exp.Expression] | t.List[exp.Expression]:
    1640        if self._match(TokenType.L_PAREN, advance=False):
    1641            return self._parse_wrapped_csv(self._parse_property)
    1642
    1643        if self._match_text_seq("JOURNAL"):
    1644            return self._parse_withjournaltable()
    1645
    1646        if self._match_text_seq("DATA"):
    1647            return self._parse_withdata(no=False)
    1648        elif self._match_text_seq("NO", "DATA"):
    1649            return self._parse_withdata(no=True)
    1650
    1651        if not self._next:
    1652            return None
    1653
    1654        return self._parse_withisolatedloading()
    1655
    1656    # https://dev.mysql.com/doc/refman/8.0/en/create-view.html
    1657    def _parse_definer(self) -> t.Optional[exp.DefinerProperty]:
    1658        self._match(TokenType.EQ)
    1659
    1660        user = self._parse_id_var()
    1661        self._match(TokenType.PARAMETER)
    1662        host = self._parse_id_var() or (self._match(TokenType.MOD) and self._prev.text)
    1663
    1664        if not user or not host:
    1665            return None
    1666
    1667        return exp.DefinerProperty(this=f"{user}@{host}")
    1668
    1669    def _parse_withjournaltable(self) -> exp.WithJournalTableProperty:
    1670        self._match(TokenType.TABLE)
    1671        self._match(TokenType.EQ)
    1672        return self.expression(exp.WithJournalTableProperty, this=self._parse_table_parts())
    1673
    1674    def _parse_log(self, no: bool = False) -> exp.LogProperty:
    1675        return self.expression(exp.LogProperty, no=no)
    1676
    1677    def _parse_journal(self, **kwargs) -> exp.JournalProperty:
    1678        return self.expression(exp.JournalProperty, **kwargs)
    1679
    1680    def _parse_checksum(self) -> exp.ChecksumProperty:
    1681        self._match(TokenType.EQ)
    1682
    1683        on = None
    1684        if self._match(TokenType.ON):
    1685            on = True
    1686        elif self._match_text_seq("OFF"):
    1687            on = False
    1688
    1689        return self.expression(exp.ChecksumProperty, on=on, default=self._match(TokenType.DEFAULT))
    1690
    1691    def _parse_cluster(self, wrapped: bool = False) -> exp.Cluster:
    1692        return self.expression(
    1693            exp.Cluster,
    1694            expressions=(
    1695                self._parse_wrapped_csv(self._parse_ordered)
    1696                if wrapped
    1697                else self._parse_csv(self._parse_ordered)
    1698            ),
    1699        )
    1700
    1701    def _parse_clustered_by(self) -> exp.ClusteredByProperty:
    1702        self._match_text_seq("BY")
    1703
    1704        self._match_l_paren()
    1705        expressions = self._parse_csv(self._parse_column)
    1706        self._match_r_paren()
    1707
    1708        if self._match_text_seq("SORTED", "BY"):
    1709            self._match_l_paren()
    1710            sorted_by = self._parse_csv(self._parse_ordered)
    1711            self._match_r_paren()
    1712        else:
    1713            sorted_by = None
    1714
    1715        self._match(TokenType.INTO)
    1716        buckets = self._parse_number()
    1717        self._match_text_seq("BUCKETS")
    1718
    1719        return self.expression(
    1720            exp.ClusteredByProperty,
    1721            expressions=expressions,
    1722            sorted_by=sorted_by,
    1723            buckets=buckets,
    1724        )
    1725
    1726    def _parse_copy_property(self) -> t.Optional[exp.CopyGrantsProperty]:
    1727        if not self._match_text_seq("GRANTS"):
    1728            self._retreat(self._index - 1)
    1729            return None
    1730
    1731        return self.expression(exp.CopyGrantsProperty)
    1732
    1733    def _parse_freespace(self) -> exp.FreespaceProperty:
    1734        self._match(TokenType.EQ)
    1735        return self.expression(
    1736            exp.FreespaceProperty, this=self._parse_number(), percent=self._match(TokenType.PERCENT)
    1737        )
    1738
    1739    def _parse_mergeblockratio(
    1740        self, no: bool = False, default: bool = False
    1741    ) -> exp.MergeBlockRatioProperty:
    1742        if self._match(TokenType.EQ):
    1743            return self.expression(
    1744                exp.MergeBlockRatioProperty,
    1745                this=self._parse_number(),
    1746                percent=self._match(TokenType.PERCENT),
    1747            )
    1748
    1749        return self.expression(exp.MergeBlockRatioProperty, no=no, default=default)
    1750
    1751    def _parse_datablocksize(
    1752        self,
    1753        default: t.Optional[bool] = None,
    1754        minimum: t.Optional[bool] = None,
    1755        maximum: t.Optional[bool] = None,
    1756    ) -> exp.DataBlocksizeProperty:
    1757        self._match(TokenType.EQ)
    1758        size = self._parse_number()
    1759
    1760        units = None
    1761        if self._match_texts(("BYTES", "KBYTES", "KILOBYTES")):
    1762            units = self._prev.text
    1763
    1764        return self.expression(
    1765            exp.DataBlocksizeProperty,
    1766            size=size,
    1767            units=units,
    1768            default=default,
    1769            minimum=minimum,
    1770            maximum=maximum,
    1771        )
    1772
    1773    def _parse_blockcompression(self) -> exp.BlockCompressionProperty:
    1774        self._match(TokenType.EQ)
    1775        always = self._match_text_seq("ALWAYS")
    1776        manual = self._match_text_seq("MANUAL")
    1777        never = self._match_text_seq("NEVER")
    1778        default = self._match_text_seq("DEFAULT")
    1779
    1780        autotemp = None
    1781        if self._match_text_seq("AUTOTEMP"):
    1782            autotemp = self._parse_schema()
    1783
    1784        return self.expression(
    1785            exp.BlockCompressionProperty,
    1786            always=always,
    1787            manual=manual,
    1788            never=never,
    1789            default=default,
    1790            autotemp=autotemp,
    1791        )
    1792
    1793    def _parse_withisolatedloading(self) -> exp.IsolatedLoadingProperty:
    1794        no = self._match_text_seq("NO")
    1795        concurrent = self._match_text_seq("CONCURRENT")
    1796        self._match_text_seq("ISOLATED", "LOADING")
    1797        for_all = self._match_text_seq("FOR", "ALL")
    1798        for_insert = self._match_text_seq("FOR", "INSERT")
    1799        for_none = self._match_text_seq("FOR", "NONE")
    1800        return self.expression(
    1801            exp.IsolatedLoadingProperty,
    1802            no=no,
    1803            concurrent=concurrent,
    1804            for_all=for_all,
    1805            for_insert=for_insert,
    1806            for_none=for_none,
    1807        )
    1808
    1809    def _parse_locking(self) -> exp.LockingProperty:
    1810        if self._match(TokenType.TABLE):
    1811            kind = "TABLE"
    1812        elif self._match(TokenType.VIEW):
    1813            kind = "VIEW"
    1814        elif self._match(TokenType.ROW):
    1815            kind = "ROW"
    1816        elif self._match_text_seq("DATABASE"):
    1817            kind = "DATABASE"
    1818        else:
    1819            kind = None
    1820
    1821        if kind in ("DATABASE", "TABLE", "VIEW"):
    1822            this = self._parse_table_parts()
    1823        else:
    1824            this = None
    1825
    1826        if self._match(TokenType.FOR):
    1827            for_or_in = "FOR"
    1828        elif self._match(TokenType.IN):
    1829            for_or_in = "IN"
    1830        else:
    1831            for_or_in = None
    1832
    1833        if self._match_text_seq("ACCESS"):
    1834            lock_type = "ACCESS"
    1835        elif self._match_texts(("EXCL", "EXCLUSIVE")):
    1836            lock_type = "EXCLUSIVE"
    1837        elif self._match_text_seq("SHARE"):
    1838            lock_type = "SHARE"
    1839        elif self._match_text_seq("READ"):
    1840            lock_type = "READ"
    1841        elif self._match_text_seq("WRITE"):
    1842            lock_type = "WRITE"
    1843        elif self._match_text_seq("CHECKSUM"):
    1844            lock_type = "CHECKSUM"
    1845        else:
    1846            lock_type = None
    1847
    1848        override = self._match_text_seq("OVERRIDE")
    1849
    1850        return self.expression(
    1851            exp.LockingProperty,
    1852            this=this,
    1853            kind=kind,
    1854            for_or_in=for_or_in,
    1855            lock_type=lock_type,
    1856            override=override,
    1857        )
    1858
    1859    def _parse_partition_by(self) -> t.List[exp.Expression]:
    1860        if self._match(TokenType.PARTITION_BY):
    1861            return self._parse_csv(self._parse_conjunction)
    1862        return []
    1863
    1864    def _parse_partition_bound_spec(self) -> exp.PartitionBoundSpec:
    1865        def _parse_partition_bound_expr() -> t.Optional[exp.Expression]:
    1866            if self._match_text_seq("MINVALUE"):
    1867                return exp.var("MINVALUE")
    1868            if self._match_text_seq("MAXVALUE"):
    1869                return exp.var("MAXVALUE")
    1870            return self._parse_bitwise()
    1871
    1872        this: t.Optional[exp.Expression | t.List[exp.Expression]] = None
    1873        expression = None
    1874        from_expressions = None
    1875        to_expressions = None
    1876
    1877        if self._match(TokenType.IN):
    1878            this = self._parse_wrapped_csv(self._parse_bitwise)
    1879        elif self._match(TokenType.FROM):
    1880            from_expressions = self._parse_wrapped_csv(_parse_partition_bound_expr)
    1881            self._match_text_seq("TO")
    1882            to_expressions = self._parse_wrapped_csv(_parse_partition_bound_expr)
    1883        elif self._match_text_seq("WITH", "(", "MODULUS"):
    1884            this = self._parse_number()
    1885            self._match_text_seq(",", "REMAINDER")
    1886            expression = self._parse_number()
    1887            self._match_r_paren()
    1888        else:
    1889            self.raise_error("Failed to parse partition bound spec.")
    1890
    1891        return self.expression(
    1892            exp.PartitionBoundSpec,
    1893            this=this,
    1894            expression=expression,
    1895            from_expressions=from_expressions,
    1896            to_expressions=to_expressions,
    1897        )
    1898
    1899    # https://www.postgresql.org/docs/current/sql-createtable.html
    1900    def _parse_partitioned_of(self) -> t.Optional[exp.PartitionedOfProperty]:
    1901        if not self._match_text_seq("OF"):
    1902            self._retreat(self._index - 1)
    1903            return None
    1904
    1905        this = self._parse_table(schema=True)
    1906
    1907        if self._match(TokenType.DEFAULT):
    1908            expression: exp.Var | exp.PartitionBoundSpec = exp.var("DEFAULT")
    1909        elif self._match_text_seq("FOR", "VALUES"):
    1910            expression = self._parse_partition_bound_spec()
    1911        else:
    1912            self.raise_error("Expecting either DEFAULT or FOR VALUES clause.")
    1913
    1914        return self.expression(exp.PartitionedOfProperty, this=this, expression=expression)
    1915
    1916    def _parse_partitioned_by(self) -> exp.PartitionedByProperty:
    1917        self._match(TokenType.EQ)
    1918        return self.expression(
    1919            exp.PartitionedByProperty,
    1920            this=self._parse_schema() or self._parse_bracket(self._parse_field()),
    1921        )
    1922
    1923    def _parse_withdata(self, no: bool = False) -> exp.WithDataProperty:
    1924        if self._match_text_seq("AND", "STATISTICS"):
    1925            statistics = True
    1926        elif self._match_text_seq("AND", "NO", "STATISTICS"):
    1927            statistics = False
    1928        else:
    1929            statistics = None
    1930
    1931        return self.expression(exp.WithDataProperty, no=no, statistics=statistics)
    1932
    1933    def _parse_contains_property(self) -> t.Optional[exp.SqlReadWriteProperty]:
    1934        if self._match_text_seq("SQL"):
    1935            return self.expression(exp.SqlReadWriteProperty, this="CONTAINS SQL")
    1936        return None
    1937
    1938    def _parse_modifies_property(self) -> t.Optional[exp.SqlReadWriteProperty]:
    1939        if self._match_text_seq("SQL", "DATA"):
    1940            return self.expression(exp.SqlReadWriteProperty, this="MODIFIES SQL DATA")
    1941        return None
    1942
    1943    def _parse_no_property(self) -> t.Optional[exp.Expression]:
    1944        if self._match_text_seq("PRIMARY", "INDEX"):
    1945            return exp.NoPrimaryIndexProperty()
    1946        if self._match_text_seq("SQL"):
    1947            return self.expression(exp.SqlReadWriteProperty, this="NO SQL")
    1948        return None
    1949
    1950    def _parse_on_property(self) -> t.Optional[exp.Expression]:
    1951        if self._match_text_seq("COMMIT", "PRESERVE", "ROWS"):
    1952            return exp.OnCommitProperty()
    1953        if self._match_text_seq("COMMIT", "DELETE", "ROWS"):
    1954            return exp.OnCommitProperty(delete=True)
    1955        return self.expression(exp.OnProperty, this=self._parse_schema(self._parse_id_var()))
    1956
    1957    def _parse_reads_property(self) -> t.Optional[exp.SqlReadWriteProperty]:
    1958        if self._match_text_seq("SQL", "DATA"):
    1959            return self.expression(exp.SqlReadWriteProperty, this="READS SQL DATA")
    1960        return None
    1961
    1962    def _parse_distkey(self) -> exp.DistKeyProperty:
    1963        return self.expression(exp.DistKeyProperty, this=self._parse_wrapped(self._parse_id_var))
    1964
    1965    def _parse_create_like(self) -> t.Optional[exp.LikeProperty]:
    1966        table = self._parse_table(schema=True)
    1967
    1968        options = []
    1969        while self._match_texts(("INCLUDING", "EXCLUDING")):
    1970            this = self._prev.text.upper()
    1971
    1972            id_var = self._parse_id_var()
    1973            if not id_var:
    1974                return None
    1975
    1976            options.append(
    1977                self.expression(exp.Property, this=this, value=exp.var(id_var.this.upper()))
    1978            )
    1979
    1980        return self.expression(exp.LikeProperty, this=table, expressions=options)
    1981
    1982    def _parse_sortkey(self, compound: bool = False) -> exp.SortKeyProperty:
    1983        return self.expression(
    1984            exp.SortKeyProperty, this=self._parse_wrapped_id_vars(), compound=compound
    1985        )
    1986
    1987    def _parse_character_set(self, default: bool = False) -> exp.CharacterSetProperty:
    1988        self._match(TokenType.EQ)
    1989        return self.expression(
    1990            exp.CharacterSetProperty, this=self._parse_var_or_string(), default=default
    1991        )
    1992
    1993    def _parse_remote_with_connection(self) -> exp.RemoteWithConnectionModelProperty:
    1994        self._match_text_seq("WITH", "CONNECTION")
    1995        return self.expression(
    1996            exp.RemoteWithConnectionModelProperty, this=self._parse_table_parts()
    1997        )
    1998
    1999    def _parse_returns(self) -> exp.ReturnsProperty:
    2000        value: t.Optional[exp.Expression]
    2001        is_table = self._match(TokenType.TABLE)
    2002
    2003        if is_table:
    2004            if self._match(TokenType.LT):
    2005                value = self.expression(
    2006                    exp.Schema,
    2007                    this="TABLE",
    2008                    expressions=self._parse_csv(self._parse_struct_types),
    2009                )
    2010                if not self._match(TokenType.GT):
    2011                    self.raise_error("Expecting >")
    2012            else:
    2013                value = self._parse_schema(exp.var("TABLE"))
    2014        else:
    2015            value = self._parse_types()
    2016
    2017        return self.expression(exp.ReturnsProperty, this=value, is_table=is_table)
    2018
    2019    def _parse_describe(self) -> exp.Describe:
    2020        kind = self._match_set(self.CREATABLES) and self._prev.text
    2021        extended = self._match_text_seq("EXTENDED")
    2022        this = self._parse_table(schema=True)
    2023        properties = self._parse_properties()
    2024        expressions = properties.expressions if properties else None
    2025        return self.expression(
    2026            exp.Describe, this=this, extended=extended, kind=kind, expressions=expressions
    2027        )
    2028
    2029    def _parse_insert(self) -> exp.Insert:
    2030        comments = ensure_list(self._prev_comments)
    2031        overwrite = self._match(TokenType.OVERWRITE)
    2032        ignore = self._match(TokenType.IGNORE)
    2033        local = self._match_text_seq("LOCAL")
    2034        alternative = None
    2035
    2036        if self._match_text_seq("DIRECTORY"):
    2037            this: t.Optional[exp.Expression] = self.expression(
    2038                exp.Directory,
    2039                this=self._parse_var_or_string(),
    2040                local=local,
    2041                row_format=self._parse_row_format(match_row=True),
    2042            )
    2043        else:
    2044            if self._match(TokenType.OR):
    2045                alternative = self._match_texts(self.INSERT_ALTERNATIVES) and self._prev.text
    2046
    2047            self._match(TokenType.INTO)
    2048            comments += ensure_list(self._prev_comments)
    2049            self._match(TokenType.TABLE)
    2050            this = self._parse_table(schema=True)
    2051
    2052        returning = self._parse_returning()
    2053
    2054        return self.expression(
    2055            exp.Insert,
    2056            comments=comments,
    2057            this=this,
    2058            by_name=self._match_text_seq("BY", "NAME"),
    2059            exists=self._parse_exists(),
    2060            partition=self._parse_partition(),
    2061            where=self._match_pair(TokenType.REPLACE, TokenType.WHERE)
    2062            and self._parse_conjunction(),
    2063            expression=self._parse_ddl_select(),
    2064            conflict=self._parse_on_conflict(),
    2065            returning=returning or self._parse_returning(),
    2066            overwrite=overwrite,
    2067            alternative=alternative,
    2068            ignore=ignore,
    2069        )
    2070
    2071    def _parse_kill(self) -> exp.Kill:
    2072        kind = exp.var(self._prev.text) if self._match_texts(("CONNECTION", "QUERY")) else None
    2073
    2074        return self.expression(
    2075            exp.Kill,
    2076            this=self._parse_primary(),
    2077            kind=kind,
    2078        )
    2079
    2080    def _parse_on_conflict(self) -> t.Optional[exp.OnConflict]:
    2081        conflict = self._match_text_seq("ON", "CONFLICT")
    2082        duplicate = self._match_text_seq("ON", "DUPLICATE", "KEY")
    2083
    2084        if not conflict and not duplicate:
    2085            return None
    2086
    2087        nothing = None
    2088        expressions = None
    2089        key = None
    2090        constraint = None
    2091
    2092        if conflict:
    2093            if self._match_text_seq("ON", "CONSTRAINT"):
    2094                constraint = self._parse_id_var()
    2095            else:
    2096                key = self._parse_csv(self._parse_value)
    2097
    2098        self._match_text_seq("DO")
    2099        if self._match_text_seq("NOTHING"):
    2100            nothing = True
    2101        else:
    2102            self._match(TokenType.UPDATE)
    2103            self._match(TokenType.SET)
    2104            expressions = self._parse_csv(self._parse_equality)
    2105
    2106        return self.expression(
    2107            exp.OnConflict,
    2108            duplicate=duplicate,
    2109            expressions=expressions,
    2110            nothing=nothing,
    2111            key=key,
    2112            constraint=constraint,
    2113        )
    2114
    2115    def _parse_returning(self) -> t.Optional[exp.Returning]:
    2116        if not self._match(TokenType.RETURNING):
    2117            return None
    2118        return self.expression(
    2119            exp.Returning,
    2120            expressions=self._parse_csv(self._parse_expression),
    2121            into=self._match(TokenType.INTO) and self._parse_table_part(),
    2122        )
    2123
    2124    def _parse_row(self) -> t.Optional[exp.RowFormatSerdeProperty | exp.RowFormatDelimitedProperty]:
    2125        if not self._match(TokenType.FORMAT):
    2126            return None
    2127        return self._parse_row_format()
    2128
    2129    def _parse_row_format(
    2130        self, match_row: bool = False
    2131    ) -> t.Optional[exp.RowFormatSerdeProperty | exp.RowFormatDelimitedProperty]:
    2132        if match_row and not self._match_pair(TokenType.ROW, TokenType.FORMAT):
    2133            return None
    2134
    2135        if self._match_text_seq("SERDE"):
    2136            this = self._parse_string()
    2137
    2138            serde_properties = None
    2139            if self._match(TokenType.SERDE_PROPERTIES):
    2140                serde_properties = self.expression(
    2141                    exp.SerdeProperties, expressions=self._parse_wrapped_csv(self._parse_property)
    2142                )
    2143
    2144            return self.expression(
    2145                exp.RowFormatSerdeProperty, this=this, serde_properties=serde_properties
    2146            )
    2147
    2148        self._match_text_seq("DELIMITED")
    2149
    2150        kwargs = {}
    2151
    2152        if self._match_text_seq("FIELDS", "TERMINATED", "BY"):
    2153            kwargs["fields"] = self._parse_string()
    2154            if self._match_text_seq("ESCAPED", "BY"):
    2155                kwargs["escaped"] = self._parse_string()
    2156        if self._match_text_seq("COLLECTION", "ITEMS", "TERMINATED", "BY"):
    2157            kwargs["collection_items"] = self._parse_string()
    2158        if self._match_text_seq("MAP", "KEYS", "TERMINATED", "BY"):
    2159            kwargs["map_keys"] = self._parse_string()
    2160        if self._match_text_seq("LINES", "TERMINATED", "BY"):
    2161            kwargs["lines"] = self._parse_string()
    2162        if self._match_text_seq("NULL", "DEFINED", "AS"):
    2163            kwargs["null"] = self._parse_string()
    2164
    2165        return self.expression(exp.RowFormatDelimitedProperty, **kwargs)  # type: ignore
    2166
    2167    def _parse_load(self) -> exp.LoadData | exp.Command:
    2168        if self._match_text_seq("DATA"):
    2169            local = self._match_text_seq("LOCAL")
    2170            self._match_text_seq("INPATH")
    2171            inpath = self._parse_string()
    2172            overwrite = self._match(TokenType.OVERWRITE)
    2173            self._match_pair(TokenType.INTO, TokenType.TABLE)
    2174
    2175            return self.expression(
    2176                exp.LoadData,
    2177                this=self._parse_table(schema=True),
    2178                local=local,
    2179                overwrite=overwrite,
    2180                inpath=inpath,
    2181                partition=self._parse_partition(),
    2182                input_format=self._match_text_seq("INPUTFORMAT") and self._parse_string(),
    2183                serde=self._match_text_seq("SERDE") and self._parse_string(),
    2184            )
    2185        return self._parse_as_command(self._prev)
    2186
    2187    def _parse_delete(self) -> exp.Delete:
    2188        # This handles MySQL's "Multiple-Table Syntax"
    2189        # https://dev.mysql.com/doc/refman/8.0/en/delete.html
    2190        tables = None
    2191        comments = self._prev_comments
    2192        if not self._match(TokenType.FROM, advance=False):
    2193            tables = self._parse_csv(self._parse_table) or None
    2194
    2195        returning = self._parse_returning()
    2196
    2197        return self.expression(
    2198            exp.Delete,
    2199            comments=comments,
    2200            tables=tables,
    2201            this=self._match(TokenType.FROM) and self._parse_table(joins=True),
    2202            using=self._match(TokenType.USING) and self._parse_table(joins=True),
    2203            where=self._parse_where(),
    2204            returning=returning or self._parse_returning(),
    2205            limit=self._parse_limit(),
    2206        )
    2207
    2208    def _parse_update(self) -> exp.Update:
    2209        comments = self._prev_comments
    2210        this = self._parse_table(joins=True, alias_tokens=self.UPDATE_ALIAS_TOKENS)
    2211        expressions = self._match(TokenType.SET) and self._parse_csv(self._parse_equality)
    2212        returning = self._parse_returning()
    2213        return self.expression(
    2214            exp.Update,
    2215            comments=comments,
    2216            **{  # type: ignore
    2217                "this": this,
    2218                "expressions": expressions,
    2219                "from": self._parse_from(joins=True),
    2220                "where": self._parse_where(),
    2221                "returning": returning or self._parse_returning(),
    2222                "order": self._parse_order(),
    2223                "limit": self._parse_limit(),
    2224            },
    2225        )
    2226
    2227    def _parse_uncache(self) -> exp.Uncache:
    2228        if not self._match(TokenType.TABLE):
    2229            self.raise_error("Expecting TABLE after UNCACHE")
    2230
    2231        return self.expression(
    2232            exp.Uncache, exists=self._parse_exists(), this=self._parse_table(schema=True)
    2233        )
    2234
    2235    def _parse_cache(self) -> exp.Cache:
    2236        lazy = self._match_text_seq("LAZY")
    2237        self._match(TokenType.TABLE)
    2238        table = self._parse_table(schema=True)
    2239
    2240        options = []
    2241        if self._match_text_seq("OPTIONS"):
    2242            self._match_l_paren()
    2243            k = self._parse_string()
    2244            self._match(TokenType.EQ)
    2245            v = self._parse_string()
    2246            options = [k, v]
    2247            self._match_r_paren()
    2248
    2249        self._match(TokenType.ALIAS)
    2250        return self.expression(
    2251            exp.Cache,
    2252            this=table,
    2253            lazy=lazy,
    2254            options=options,
    2255            expression=self._parse_select(nested=True),
    2256        )
    2257
    2258    def _parse_partition(self) -> t.Optional[exp.Partition]:
    2259        if not self._match(TokenType.PARTITION):
    2260            return None
    2261
    2262        return self.expression(
    2263            exp.Partition, expressions=self._parse_wrapped_csv(self._parse_conjunction)
    2264        )
    2265
    2266    def _parse_value(self) -> exp.Tuple:
    2267        if self._match(TokenType.L_PAREN):
    2268            expressions = self._parse_csv(self._parse_expression)
    2269            self._match_r_paren()
    2270            return self.expression(exp.Tuple, expressions=expressions)
    2271
    2272        # In presto we can have VALUES 1, 2 which results in 1 column & 2 rows.
    2273        # https://prestodb.io/docs/current/sql/values.html
    2274        return self.expression(exp.Tuple, expressions=[self._parse_expression()])
    2275
    2276    def _parse_projections(self) -> t.List[exp.Expression]:
    2277        return self._parse_expressions()
    2278
    2279    def _parse_select(
    2280        self,
    2281        nested: bool = False,
    2282        table: bool = False,
    2283        parse_subquery_alias: bool = True,
    2284        parse_set_operation: bool = True,
    2285    ) -> t.Optional[exp.Expression]:
    2286        cte = self._parse_with()
    2287
    2288        if cte:
    2289            this = self._parse_statement()
    2290
    2291            if not this:
    2292                self.raise_error("Failed to parse any statement following CTE")
    2293                return cte
    2294
    2295            if "with" in this.arg_types:
    2296                this.set("with", cte)
    2297            else:
    2298                self.raise_error(f"{this.key} does not support CTE")
    2299                this = cte
    2300
    2301            return this
    2302
    2303        # duckdb supports leading with FROM x
    2304        from_ = self._parse_from() if self._match(TokenType.FROM, advance=False) else None
    2305
    2306        if self._match(TokenType.SELECT):
    2307            comments = self._prev_comments
    2308
    2309            hint = self._parse_hint()
    2310            all_ = self._match(TokenType.ALL)
    2311            distinct = self._match_set(self.DISTINCT_TOKENS)
    2312
    2313            kind = (
    2314                self._match(TokenType.ALIAS)
    2315                and self._match_texts(("STRUCT", "VALUE"))
    2316                and self._prev.text.upper()
    2317            )
    2318
    2319            if distinct:
    2320                distinct = self.expression(
    2321                    exp.Distinct,
    2322                    on=self._parse_value() if self._match(TokenType.ON) else None,
    2323                )
    2324
    2325            if all_ and distinct:
    2326                self.raise_error("Cannot specify both ALL and DISTINCT after SELECT")
    2327
    2328            limit = self._parse_limit(top=True)
    2329            projections = self._parse_projections()
    2330
    2331            this = self.expression(
    2332                exp.Select,
    2333                kind=kind,
    2334                hint=hint,
    2335                distinct=distinct,
    2336                expressions=projections,
    2337                limit=limit,
    2338            )
    2339            this.comments = comments
    2340
    2341            into = self._parse_into()
    2342            if into:
    2343                this.set("into", into)
    2344
    2345            if not from_:
    2346                from_ = self._parse_from()
    2347
    2348            if from_:
    2349                this.set("from", from_)
    2350
    2351            this = self._parse_query_modifiers(this)
    2352        elif (table or nested) and self._match(TokenType.L_PAREN):
    2353            if self._match(TokenType.PIVOT):
    2354                this = self._parse_simplified_pivot()
    2355            elif self._match(TokenType.FROM):
    2356                this = exp.select("*").from_(
    2357                    t.cast(exp.From, self._parse_from(skip_from_token=True))
    2358                )
    2359            else:
    2360                this = (
    2361                    self._parse_table()
    2362                    if table
    2363                    else self._parse_select(nested=True, parse_set_operation=False)
    2364                )
    2365                this = self._parse_query_modifiers(self._parse_set_operations(this))
    2366
    2367            self._match_r_paren()
    2368
    2369            # We return early here so that the UNION isn't attached to the subquery by the
    2370            # following call to _parse_set_operations, but instead becomes the parent node
    2371            return self._parse_subquery(this, parse_alias=parse_subquery_alias)
    2372        elif self._match(TokenType.VALUES):
    2373            this = self.expression(
    2374                exp.Values,
    2375                expressions=self._parse_csv(self._parse_value),
    2376                alias=self._parse_table_alias(),
    2377            )
    2378        elif from_:
    2379            this = exp.select("*").from_(from_.this, copy=False)
    2380        else:
    2381            this = None
    2382
    2383        if parse_set_operation:
    2384            return self._parse_set_operations(this)
    2385        return this
    2386
    2387    def _parse_with(self, skip_with_token: bool = False) -> t.Optional[exp.With]:
    2388        if not skip_with_token and not self._match(TokenType.WITH):
    2389            return None
    2390
    2391        comments = self._prev_comments
    2392        recursive = self._match(TokenType.RECURSIVE)
    2393
    2394        expressions = []
    2395        while True:
    2396            expressions.append(self._parse_cte())
    2397
    2398            if not self._match(TokenType.COMMA) and not self._match(TokenType.WITH):
    2399                break
    2400            else:
    2401                self._match(TokenType.WITH)
    2402
    2403        return self.expression(
    2404            exp.With, comments=comments, expressions=expressions, recursive=recursive
    2405        )
    2406
    2407    def _parse_cte(self) -> exp.CTE:
    2408        alias = self._parse_table_alias(self.ID_VAR_TOKENS)
    2409        if not alias or not alias.this:
    2410            self.raise_error("Expected CTE to have alias")
    2411
    2412        self._match(TokenType.ALIAS)
    2413        return self.expression(
    2414            exp.CTE, this=self._parse_wrapped(self._parse_statement), alias=alias
    2415        )
    2416
    2417    def _parse_table_alias(
    2418        self, alias_tokens: t.Optional[t.Collection[TokenType]] = None
    2419    ) -> t.Optional[exp.TableAlias]:
    2420        any_token = self._match(TokenType.ALIAS)
    2421        alias = (
    2422            self._parse_id_var(any_token=any_token, tokens=alias_tokens or self.TABLE_ALIAS_TOKENS)
    2423            or self._parse_string_as_identifier()
    2424        )
    2425
    2426        index = self._index
    2427        if self._match(TokenType.L_PAREN):
    2428            columns = self._parse_csv(self._parse_function_parameter)
    2429            self._match_r_paren() if columns else self._retreat(index)
    2430        else:
    2431            columns = None
    2432
    2433        if not alias and not columns:
    2434            return None
    2435
    2436        return self.expression(exp.TableAlias, this=alias, columns=columns)
    2437
    2438    def _parse_subquery(
    2439        self, this: t.Optional[exp.Expression], parse_alias: bool = True
    2440    ) -> t.Optional[exp.Subquery]:
    2441        if not this:
    2442            return None
    2443
    2444        return self.expression(
    2445            exp.Subquery,
    2446            this=this,
    2447            pivots=self._parse_pivots(),
    2448            alias=self._parse_table_alias() if parse_alias else None,
    2449        )
    2450
    2451    def _parse_query_modifiers(
    2452        self, this: t.Optional[exp.Expression]
    2453    ) -> t.Optional[exp.Expression]:
    2454        if isinstance(this, self.MODIFIABLES):
    2455            for join in iter(self._parse_join, None):
    2456                this.append("joins", join)
    2457            for lateral in iter(self._parse_lateral, None):
    2458                this.append("laterals", lateral)
    2459
    2460            while True:
    2461                if self._match_set(self.QUERY_MODIFIER_PARSERS, advance=False):
    2462                    parser = self.QUERY_MODIFIER_PARSERS[self._curr.token_type]
    2463                    key, expression = parser(self)
    2464
    2465                    if expression:
    2466                        this.set(key, expression)
    2467                        if key == "limit":
    2468                            offset = expression.args.pop("offset", None)
    2469                            if offset:
    2470                                this.set("offset", exp.Offset(expression=offset))
    2471                        continue
    2472                break
    2473        return this
    2474
    2475    def _parse_hint(self) -> t.Optional[exp.Hint]:
    2476        if self._match(TokenType.HINT):
    2477            hints = []
    2478            for hint in iter(lambda: self._parse_csv(self._parse_function), []):
    2479                hints.extend(hint)
    2480
    2481            if not self._match_pair(TokenType.STAR, TokenType.SLASH):
    2482                self.raise_error("Expected */ after HINT")
    2483
    2484            return self.expression(exp.Hint, expressions=hints)
    2485
    2486        return None
    2487
    2488    def _parse_into(self) -> t.Optional[exp.Into]:
    2489        if not self._match(TokenType.INTO):
    2490            return None
    2491
    2492        temp = self._match(TokenType.TEMPORARY)
    2493        unlogged = self._match_text_seq("UNLOGGED")
    2494        self._match(TokenType.TABLE)
    2495
    2496        return self.expression(
    2497            exp.Into, this=self._parse_table(schema=True), temporary=temp, unlogged=unlogged
    2498        )
    2499
    2500    def _parse_from(
    2501        self, joins: bool = False, skip_from_token: bool = False
    2502    ) -> t.Optional[exp.From]:
    2503        if not skip_from_token and not self._match(TokenType.FROM):
    2504            return None
    2505
    2506        return self.expression(
    2507            exp.From, comments=self._prev_comments, this=self._parse_table(joins=joins)
    2508        )
    2509
    2510    def _parse_match_recognize(self) -> t.Optional[exp.MatchRecognize]:
    2511        if not self._match(TokenType.MATCH_RECOGNIZE):
    2512            return None
    2513
    2514        self._match_l_paren()
    2515
    2516        partition = self._parse_partition_by()
    2517        order = self._parse_order()
    2518        measures = self._parse_expressions() if self._match_text_seq("MEASURES") else None
    2519
    2520        if self._match_text_seq("ONE", "ROW", "PER", "MATCH"):
    2521            rows = exp.var("ONE ROW PER MATCH")
    2522        elif self._match_text_seq("ALL", "ROWS", "PER", "MATCH"):
    2523            text = "ALL ROWS PER MATCH"
    2524            if self._match_text_seq("SHOW", "EMPTY", "MATCHES"):
    2525                text += " SHOW EMPTY MATCHES"
    2526            elif self._match_text_seq("OMIT", "EMPTY", "MATCHES"):
    2527                text += " OMIT EMPTY MATCHES"
    2528            elif self._match_text_seq("WITH", "UNMATCHED", "ROWS"):
    2529                text += " WITH UNMATCHED ROWS"
    2530            rows = exp.var(text)
    2531        else:
    2532            rows = None
    2533
    2534        if self._match_text_seq("AFTER", "MATCH", "SKIP"):
    2535            text = "AFTER MATCH SKIP"
    2536            if self._match_text_seq("PAST", "LAST", "ROW"):
    2537                text += " PAST LAST ROW"
    2538            elif self._match_text_seq("TO", "NEXT", "ROW"):
    2539                text += " TO NEXT ROW"
    2540            elif self._match_text_seq("TO", "FIRST"):
    2541                text += f" TO FIRST {self._advance_any().text}"  # type: ignore
    2542            elif self._match_text_seq("TO", "LAST"):
    2543                text += f" TO LAST {self._advance_any().text}"  # type: ignore
    2544            after = exp.var(text)
    2545        else:
    2546            after = None
    2547
    2548        if self._match_text_seq("PATTERN"):
    2549            self._match_l_paren()
    2550
    2551            if not self._curr:
    2552                self.raise_error("Expecting )", self._curr)
    2553
    2554            paren = 1
    2555            start = self._curr
    2556
    2557            while self._curr and paren > 0:
    2558                if self._curr.token_type == TokenType.L_PAREN:
    2559                    paren += 1
    2560                if self._curr.token_type == TokenType.R_PAREN:
    2561                    paren -= 1
    2562
    2563                end = self._prev
    2564                self._advance()
    2565
    2566            if paren > 0:
    2567                self.raise_error("Expecting )", self._curr)
    2568
    2569            pattern = exp.var(self._find_sql(start, end))
    2570        else:
    2571            pattern = None
    2572
    2573        define = (
    2574            self._parse_csv(self._parse_name_as_expression)
    2575            if self._match_text_seq("DEFINE")
    2576            else None
    2577        )
    2578
    2579        self._match_r_paren()
    2580
    2581        return self.expression(
    2582            exp.MatchRecognize,
    2583            partition_by=partition,
    2584            order=order,
    2585            measures=measures,
    2586            rows=rows,
    2587            after=after,
    2588            pattern=pattern,
    2589            define=define,
    2590            alias=self._parse_table_alias(),
    2591        )
    2592
    2593    def _parse_lateral(self) -> t.Optional[exp.Lateral]:
    2594        cross_apply = self._match_pair(TokenType.CROSS, TokenType.APPLY)
    2595        if not cross_apply and self._match_pair(TokenType.OUTER, TokenType.APPLY):
    2596            cross_apply = False
    2597
    2598        if cross_apply is not None:
    2599            this = self._parse_select(table=True)
    2600            view = None
    2601            outer = None
    2602        elif self._match(TokenType.LATERAL):
    2603            this = self._parse_select(table=True)
    2604            view = self._match(TokenType.VIEW)
    2605            outer = self._match(TokenType.OUTER)
    2606        else:
    2607            return None
    2608
    2609        if not this:
    2610            this = (
    2611                self._parse_unnest()
    2612                or self._parse_function()
    2613                or self._parse_id_var(any_token=False)
    2614            )
    2615
    2616            while self._match(TokenType.DOT):
    2617                this = exp.Dot(
    2618                    this=this,
    2619                    expression=self._parse_function() or self._parse_id_var(any_token=False),
    2620                )
    2621
    2622        if view:
    2623            table = self._parse_id_var(any_token=False)
    2624            columns = self._parse_csv(self._parse_id_var) if self._match(TokenType.ALIAS) else []
    2625            table_alias: t.Optional[exp.TableAlias] = self.expression(
    2626                exp.TableAlias, this=table, columns=columns
    2627            )
    2628        elif isinstance(this, (exp.Subquery, exp.Unnest)) and this.alias:
    2629            # We move the alias from the lateral's child node to the lateral itself
    2630            table_alias = this.args["alias"].pop()
    2631        else:
    2632            table_alias = self._parse_table_alias()
    2633
    2634        return self.expression(
    2635            exp.Lateral,
    2636            this=this,
    2637            view=view,
    2638            outer=outer,
    2639            alias=table_alias,
    2640            cross_apply=cross_apply,
    2641        )
    2642
    2643    def _parse_join_parts(
    2644        self,
    2645    ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
    2646        return (
    2647            self._match_set(self.JOIN_METHODS) and self._prev,
    2648            self._match_set(self.JOIN_SIDES) and self._prev,
    2649            self._match_set(self.JOIN_KINDS) and self._prev,
    2650        )
    2651
    2652    def _parse_join(
    2653        self, skip_join_token: bool = False, parse_bracket: bool = False
    2654    ) -> t.Optional[exp.Join]:
    2655        if self._match(TokenType.COMMA):
    2656            return self.expression(exp.Join, this=self._parse_table())
    2657
    2658        index = self._index
    2659        method, side, kind = self._parse_join_parts()
    2660        hint = self._prev.text if self._match_texts(self.JOIN_HINTS) else None
    2661        join = self._match(TokenType.JOIN)
    2662
    2663        if not skip_join_token and not join:
    2664            self._retreat(index)
    2665            kind = None
    2666            method = None
    2667            side = None
    2668
    2669        outer_apply = self._match_pair(TokenType.OUTER, TokenType.APPLY, False)
    2670        cross_apply = self._match_pair(TokenType.CROSS, TokenType.APPLY, False)
    2671
    2672        if not skip_join_token and not join and not outer_apply and not cross_apply:
    2673            return None
    2674
    2675        kwargs: t.Dict[str, t.Any] = {"this": self._parse_table(parse_bracket=parse_bracket)}
    2676
    2677        if method:
    2678            kwargs["method"] = method.text
    2679        if side:
    2680            kwargs["side"] = side.text
    2681        if kind:
    2682            kwargs["kind"] = kind.text
    2683        if hint:
    2684            kwargs["hint"] = hint
    2685
    2686        if self._match(TokenType.ON):
    2687            kwargs["on"] = self._parse_conjunction()
    2688        elif self._match(TokenType.USING):
    2689            kwargs["using"] = self._parse_wrapped_id_vars()
    2690        elif not (kind and kind.token_type == TokenType.CROSS):
    2691            index = self._index
    2692            join = self._parse_join()
    2693
    2694            if join and self._match(TokenType.ON):
    2695                kwargs["on"] = self._parse_conjunction()
    2696            elif join and self._match(TokenType.USING):
    2697                kwargs["using"] = self._parse_wrapped_id_vars()
    2698            else:
    2699                join = None
    2700                self._retreat(index)
    2701
    2702            kwargs["this"].set("joins", [join] if join else None)
    2703
    2704        comments = [c for token in (method, side, kind) if token for c in token.comments]
    2705        return self.expression(exp.Join, comments=comments, **kwargs)
    2706
    2707    def _parse_opclass(self) -> t.Optional[exp.Expression]:
    2708        this = self._parse_conjunction()
    2709        if self._match_texts(self.OPCLASS_FOLLOW_KEYWORDS, advance=False):
    2710            return this
    2711
    2712        if not self._match_set(self.OPTYPE_FOLLOW_TOKENS, advance=False):
    2713            return self.expression(exp.Opclass, this=this, expression=self._parse_table_parts())
    2714
    2715        return this
    2716
    2717    def _parse_index(
    2718        self,
    2719        index: t.Optional[exp.Expression] = None,
    2720    ) -> t.Optional[exp.Index]:
    2721        if index:
    2722            unique = None
    2723            primary = None
    2724            amp = None
    2725
    2726            self._match(TokenType.ON)
    2727            self._match(TokenType.TABLE)  # hive
    2728            table = self._parse_table_parts(schema=True)
    2729        else:
    2730            unique = self._match(TokenType.UNIQUE)
    2731            primary = self._match_text_seq("PRIMARY")
    2732            amp = self._match_text_seq("AMP")
    2733
    2734            if not self._match(TokenType.INDEX):
    2735                return None
    2736
    2737            index = self._parse_id_var()
    2738            table = None
    2739
    2740        using = self._parse_var(any_token=True) if self._match(TokenType.USING) else None
    2741
    2742        if self._match(TokenType.L_PAREN, advance=False):
    2743            columns = self._parse_wrapped_csv(lambda: self._parse_ordered(self._parse_opclass))
    2744        else:
    2745            columns = None
    2746
    2747        include = self._parse_wrapped_id_vars() if self._match_text_seq("INCLUDE") else None
    2748
    2749        return self.expression(
    2750            exp.Index,
    2751            this=index,
    2752            table=table,
    2753            using=using,
    2754            columns=columns,
    2755            unique=unique,
    2756            primary=primary,
    2757            amp=amp,
    2758            include=include,
    2759            partition_by=self._parse_partition_by(),
    2760            where=self._parse_where(),
    2761        )
    2762
    2763    def _parse_table_hints(self) -> t.Optional[t.List[exp.Expression]]:
    2764        hints: t.List[exp.Expression] = []
    2765        if self._match_pair(TokenType.WITH, TokenType.L_PAREN):
    2766            # https://learn.microsoft.com/en-us/sql/t-sql/queries/hints-transact-sql-table?view=sql-server-ver16
    2767            hints.append(
    2768                self.expression(
    2769                    exp.WithTableHint,
    2770                    expressions=self._parse_csv(
    2771                        lambda: self._parse_function() or self._parse_var(any_token=True)
    2772                    ),
    2773                )
    2774            )
    2775            self._match_r_paren()
    2776        else:
    2777            # https://dev.mysql.com/doc/refman/8.0/en/index-hints.html
    2778            while self._match_set(self.TABLE_INDEX_HINT_TOKENS):
    2779                hint = exp.IndexTableHint(this=self._prev.text.upper())
    2780
    2781                self._match_texts(("INDEX", "KEY"))
    2782                if self._match(TokenType.FOR):
    2783                    hint.set("target", self._advance_any() and self._prev.text.upper())
    2784
    2785                hint.set("expressions", self._parse_wrapped_id_vars())
    2786                hints.append(hint)
    2787
    2788        return hints or None
    2789
    2790    def _parse_table_part(self, schema: bool = False) -> t.Optional[exp.Expression]:
    2791        return (
    2792            (not schema and self._parse_function(optional_parens=False))
    2793            or self._parse_id_var(any_token=False)
    2794            or self._parse_string_as_identifier()
    2795            or self._parse_placeholder()
    2796        )
    2797
    2798    def _parse_table_parts(self, schema: bool = False, is_db_reference: bool = False) -> exp.Table:
    2799        catalog = None
    2800        db = None
    2801        table: t.Optional[exp.Expression | str] = self._parse_table_part(schema=schema)
    2802
    2803        while self._match(TokenType.DOT):
    2804            if catalog:
    2805                # This allows nesting the table in arbitrarily many dot expressions if needed
    2806                table = self.expression(
    2807                    exp.Dot, this=table, expression=self._parse_table_part(schema=schema)
    2808                )
    2809            else:
    2810                catalog = db
    2811                db = table
    2812                table = self._parse_table_part(schema=schema) or ""
    2813
    2814        if is_db_reference:
    2815            catalog = db
    2816            db = table
    2817            table = None
    2818
    2819        if not table and not is_db_reference:
    2820            self.raise_error(f"Expected table name but got {self._curr}")
    2821        if not db and is_db_reference:
    2822            self.raise_error(f"Expected database name but got {self._curr}")
    2823
    2824        return self.expression(
    2825            exp.Table, this=table, db=db, catalog=catalog, pivots=self._parse_pivots()
    2826        )
    2827
    2828    def _parse_table(
    2829        self,
    2830        schema: bool = False,
    2831        joins: bool = False,
    2832        alias_tokens: t.Optional[t.Collection[TokenType]] = None,
    2833        parse_bracket: bool = False,
    2834        is_db_reference: bool = False,
    2835    ) -> t.Optional[exp.Expression]:
    2836        lateral = self._parse_lateral()
    2837        if lateral:
    2838            return lateral
    2839
    2840        unnest = self._parse_unnest()
    2841        if unnest:
    2842            return unnest
    2843
    2844        values = self._parse_derived_table_values()
    2845        if values:
    2846            return values
    2847
    2848        subquery = self._parse_select(table=True)
    2849        if subquery:
    2850            if not subquery.args.get("pivots"):
    2851                subquery.set("pivots", self._parse_pivots())
    2852            return subquery
    2853
    2854        bracket = parse_bracket and self._parse_bracket(None)
    2855        bracket = self.expression(exp.Table, this=bracket) if bracket else None
    2856        this = t.cast(
    2857            exp.Expression,
    2858            bracket
    2859            or self._parse_bracket(
    2860                self._parse_table_parts(schema=schema, is_db_reference=is_db_reference)
    2861            ),
    2862        )
    2863
    2864        if schema:
    2865            return self._parse_schema(this=this)
    2866
    2867        version = self._parse_version()
    2868
    2869        if version:
    2870            this.set("version", version)
    2871
    2872        if self.dialect.ALIAS_POST_TABLESAMPLE:
    2873            table_sample = self._parse_table_sample()
    2874
    2875        alias = self._parse_table_alias(alias_tokens=alias_tokens or self.TABLE_ALIAS_TOKENS)
    2876        if alias:
    2877            this.set("alias", alias)
    2878
    2879        if isinstance(this, exp.Table) and self._match_text_seq("AT"):
    2880            return self.expression(
    2881                exp.AtIndex, this=this.to_column(copy=False), expression=self._parse_id_var()
    2882            )
    2883
    2884        this.set("hints", self._parse_table_hints())
    2885
    2886        if not this.args.get("pivots"):
    2887            this.set("pivots", self._parse_pivots())
    2888
    2889        if not self.dialect.ALIAS_POST_TABLESAMPLE:
    2890            table_sample = self._parse_table_sample()
    2891
    2892        if table_sample:
    2893            table_sample.set("this", this)
    2894            this = table_sample
    2895
    2896        if joins:
    2897            for join in iter(self._parse_join, None):
    2898                this.append("joins", join)
    2899
    2900        if self._match_pair(TokenType.WITH, TokenType.ORDINALITY):
    2901            this.set("ordinality", True)
    2902            this.set("alias", self._parse_table_alias())
    2903
    2904        return this
    2905
    2906    def _parse_version(self) -> t.Optional[exp.Version]:
    2907        if self._match(TokenType.TIMESTAMP_SNAPSHOT):
    2908            this = "TIMESTAMP"
    2909        elif self._match(TokenType.VERSION_SNAPSHOT):
    2910            this = "VERSION"
    2911        else:
    2912            return None
    2913
    2914        if self._match_set((TokenType.FROM, TokenType.BETWEEN)):
    2915            kind = self._prev.text.upper()
    2916            start = self._parse_bitwise()
    2917            self._match_texts(("TO", "AND"))
    2918            end = self._parse_bitwise()
    2919            expression: t.Optional[exp.Expression] = self.expression(
    2920                exp.Tuple, expressions=[start, end]
    2921            )
    2922        elif self._match_text_seq("CONTAINED", "IN"):
    2923            kind = "CONTAINED IN"
    2924            expression = self.expression(
    2925                exp.Tuple, expressions=self._parse_wrapped_csv(self._parse_bitwise)
    2926            )
    2927        elif self._match(TokenType.ALL):
    2928            kind = "ALL"
    2929            expression = None
    2930        else:
    2931            self._match_text_seq("AS", "OF")
    2932            kind = "AS OF"
    2933            expression = self._parse_type()
    2934
    2935        return self.expression(exp.Version, this=this, expression=expression, kind=kind)
    2936
    2937    def _parse_unnest(self, with_alias: bool = True) -> t.Optional[exp.Unnest]:
    2938        if not self._match(TokenType.UNNEST):
    2939            return None
    2940
    2941        expressions = self._parse_wrapped_csv(self._parse_equality)
    2942        offset = self._match_pair(TokenType.WITH, TokenType.ORDINALITY)
    2943
    2944        alias = self._parse_table_alias() if with_alias else None
    2945
    2946        if alias:
    2947            if self.dialect.UNNEST_COLUMN_ONLY:
    2948                if alias.args.get("columns"):
    2949                    self.raise_error("Unexpected extra column alias in unnest.")
    2950
    2951                alias.set("columns", [alias.this])
    2952                alias.set("this", None)
    2953
    2954            columns = alias.args.get("columns") or []
    2955            if offset and len(expressions) < len(columns):
    2956                offset = columns.pop()
    2957
    2958        if not offset and self._match_pair(TokenType.WITH, TokenType.OFFSET):
    2959            self._match(TokenType.ALIAS)
    2960            offset = self._parse_id_var(
    2961                any_token=False, tokens=self.UNNEST_OFFSET_ALIAS_TOKENS
    2962            ) or exp.to_identifier("offset")
    2963
    2964        return self.expression(exp.Unnest, expressions=expressions, alias=alias, offset=offset)
    2965
    2966    def _parse_derived_table_values(self) -> t.Optional[exp.Values]:
    2967        is_derived = self._match_pair(TokenType.L_PAREN, TokenType.VALUES)
    2968        if not is_derived and not self._match(TokenType.VALUES):
    2969            return None
    2970
    2971        expressions = self._parse_csv(self._parse_value)
    2972        alias = self._parse_table_alias()
    2973
    2974        if is_derived:
    2975            self._match_r_paren()
    2976
    2977        return self.expression(
    2978            exp.Values, expressions=expressions, alias=alias or self._parse_table_alias()
    2979        )
    2980
    2981    def _parse_table_sample(self, as_modifier: bool = False) -> t.Optional[exp.TableSample]:
    2982        if not self._match(TokenType.TABLE_SAMPLE) and not (
    2983            as_modifier and self._match_text_seq("USING", "SAMPLE")
    2984        ):
    2985            return None
    2986
    2987        bucket_numerator = None
    2988        bucket_denominator = None
    2989        bucket_field = None
    2990        percent = None
    2991        size = None
    2992        seed = None
    2993
    2994        method = self._parse_var(tokens=(TokenType.ROW,), upper=True)
    2995        matched_l_paren = self._match(TokenType.L_PAREN)
    2996
    2997        if self.TABLESAMPLE_CSV:
    2998            num = None
    2999            expressions = self._parse_csv(self._parse_primary)
    3000        else:
    3001            expressions = None
    3002            num = (
    3003                self._parse_factor()
    3004                if self._match(TokenType.NUMBER, advance=False)
    3005                else self._parse_primary() or self._parse_placeholder()
    3006            )
    3007
    3008        if self._match_text_seq("BUCKET"):
    3009            bucket_numerator = self._parse_number()
    3010            self._match_text_seq("OUT", "OF")
    3011            bucket_denominator = bucket_denominator = self._parse_number()
    3012            self._match(TokenType.ON)
    3013            bucket_field = self._parse_field()
    3014        elif self._match_set((TokenType.PERCENT, TokenType.MOD)):
    3015            percent = num
    3016        elif self._match(TokenType.ROWS) or not self.dialect.TABLESAMPLE_SIZE_IS_PERCENT:
    3017            size = num
    3018        else:
    3019            percent = num
    3020
    3021        if matched_l_paren:
    3022            self._match_r_paren()
    3023
    3024        if self._match(TokenType.L_PAREN):
    3025            method = self._parse_var(upper=True)
    3026            seed = self._match(TokenType.COMMA) and self._parse_number()
    3027            self._match_r_paren()
    3028        elif self._match_texts(("SEED", "REPEATABLE")):
    3029            seed = self._parse_wrapped(self._parse_number)
    3030
    3031        return self.expression(
    3032            exp.TableSample,
    3033            expressions=expressions,
    3034            method=method,
    3035            bucket_numerator=bucket_numerator,
    3036            bucket_denominator=bucket_denominator,
    3037            bucket_field=bucket_field,
    3038            percent=percent,
    3039            size=size,
    3040            seed=seed,
    3041        )
    3042
    3043    def _parse_pivots(self) -> t.Optional[t.List[exp.Pivot]]:
    3044        return list(iter(self._parse_pivot, None)) or None
    3045
    3046    def _parse_joins(self) -> t.Optional[t.List[exp.Join]]:
    3047        return list(iter(self._parse_join, None)) or None
    3048
    3049    # https://duckdb.org/docs/sql/statements/pivot
    3050    def _parse_simplified_pivot(self) -> exp.Pivot:
    3051        def _parse_on() -> t.Optional[exp.Expression]:
    3052            this = self._parse_bitwise()
    3053            return self._parse_in(this) if self._match(TokenType.IN) else this
    3054
    3055        this = self._parse_table()
    3056        expressions = self._match(TokenType.ON) and self._parse_csv(_parse_on)
    3057        using = self._match(TokenType.USING) and self._parse_csv(
    3058            lambda: self._parse_alias(self._parse_function())
    3059        )
    3060        group = self._parse_group()
    3061        return self.expression(
    3062            exp.Pivot, this=this, expressions=expressions, using=using, group=group
    3063        )
    3064
    3065    def _parse_pivot_in(self) -> exp.In:
    3066        def _parse_aliased_expression() -> t.Optional[exp.Expression]:
    3067            this = self._parse_conjunction()
    3068
    3069            self._match(TokenType.ALIAS)
    3070            alias = self._parse_field()
    3071            if alias:
    3072                return self.expression(exp.PivotAlias, this=this, alias=alias)
    3073
    3074            return this
    3075
    3076        value = self._parse_column()
    3077
    3078        if not self._match_pair(TokenType.IN, TokenType.L_PAREN):
    3079            self.raise_error("Expecting IN (")
    3080
    3081        aliased_expressions = self._parse_csv(_parse_aliased_expression)
    3082
    3083        self._match_r_paren()
    3084        return self.expression(exp.In, this=value, expressions=aliased_expressions)
    3085
    3086    def _parse_pivot(self) -> t.Optional[exp.Pivot]:
    3087        index = self._index
    3088        include_nulls = None
    3089
    3090        if self._match(TokenType.PIVOT):
    3091            unpivot = False
    3092        elif self._match(TokenType.UNPIVOT):
    3093            unpivot = True
    3094
    3095            # https://docs.databricks.com/en/sql/language-manual/sql-ref-syntax-qry-select-unpivot.html#syntax
    3096            if self._match_text_seq("INCLUDE", "NULLS"):
    3097                include_nulls = True
    3098            elif self._match_text_seq("EXCLUDE", "NULLS"):
    3099                include_nulls = False
    3100        else:
    3101            return None
    3102
    3103        expressions = []
    3104
    3105        if not self._match(TokenType.L_PAREN):
    3106            self._retreat(index)
    3107            return None
    3108
    3109        if unpivot:
    3110            expressions = self._parse_csv(self._parse_column)
    3111        else:
    3112            expressions = self._parse_csv(lambda: self._parse_alias(self._parse_function()))
    3113
    3114        if not expressions:
    3115            self.raise_error("Failed to parse PIVOT's aggregation list")
    3116
    3117        if not self._match(TokenType.FOR):
    3118            self.raise_error("Expecting FOR")
    3119
    3120        field = self._parse_pivot_in()
    3121
    3122        self._match_r_paren()
    3123
    3124        pivot = self.expression(
    3125            exp.Pivot,
    3126            expressions=expressions,
    3127            field=field,
    3128            unpivot=unpivot,
    3129            include_nulls=include_nulls,
    3130        )
    3131
    3132        if not self._match_set((TokenType.PIVOT, TokenType.UNPIVOT), advance=False):
    3133            pivot.set("alias", self._parse_table_alias())
    3134
    3135        if not unpivot:
    3136            names = self._pivot_column_names(t.cast(t.List[exp.Expression], expressions))
    3137
    3138            columns: t.List[exp.Expression] = []
    3139            for fld in pivot.args["field"].expressions:
    3140                field_name = fld.sql() if self.IDENTIFY_PIVOT_STRINGS else fld.alias_or_name
    3141                for name in names:
    3142                    if self.PREFIXED_PIVOT_COLUMNS:
    3143                        name = f"{name}_{field_name}" if name else field_name
    3144                    else:
    3145                        name = f"{field_name}_{name}" if name else field_name
    3146
    3147                    columns.append(exp.to_identifier(name))
    3148
    3149            pivot.set("columns", columns)
    3150
    3151        return pivot
    3152
    3153    def _pivot_column_names(self, aggregations: t.List[exp.Expression]) -> t.List[str]:
    3154        return [agg.alias for agg in aggregations]
    3155
    3156    def _parse_where(self, skip_where_token: bool = False) -> t.Optional[exp.Where]:
    3157        if not skip_where_token and not self._match(TokenType.WHERE):
    3158            return None
    3159
    3160        return self.expression(
    3161            exp.Where, comments=self._prev_comments, this=self._parse_conjunction()
    3162        )
    3163
    3164    def _parse_group(self, skip_group_by_token: bool = False) -> t.Optional[exp.Group]:
    3165        if not skip_group_by_token and not self._match(TokenType.GROUP_BY):
    3166            return None
    3167
    3168        elements = defaultdict(list)
    3169
    3170        if self._match(TokenType.ALL):
    3171            return self.expression(exp.Group, all=True)
    3172
    3173        while True:
    3174            expressions = self._parse_csv(self._parse_conjunction)
    3175            if expressions:
    3176                elements["expressions"].extend(expressions)
    3177
    3178            grouping_sets = self._parse_grouping_sets()
    3179            if grouping_sets:
    3180                elements["grouping_sets"].extend(grouping_sets)
    3181
    3182            rollup = None
    3183            cube = None
    3184            totals = None
    3185
    3186            index = self._index
    3187            with_ = self._match(TokenType.WITH)
    3188            if self._match(TokenType.ROLLUP):
    3189                rollup = with_ or self._parse_wrapped_csv(self._parse_column)
    3190                elements["rollup"].extend(ensure_list(rollup))
    3191
    3192            if self._match(TokenType.CUBE):
    3193                cube = with_ or self._parse_wrapped_csv(self._parse_column)
    3194                elements["cube"].extend(ensure_list(cube))
    3195
    3196            if self._match_text_seq("TOTALS"):
    3197                totals = True
    3198                elements["totals"] = True  # type: ignore
    3199
    3200            if not (grouping_sets or rollup or cube or totals):
    3201                if with_:
    3202                    self._retreat(index)
    3203                break
    3204
    3205        return self.expression(exp.Group, **elements)  # type: ignore
    3206
    3207    def _parse_grouping_sets(self) -> t.Optional[t.List[exp.Expression]]:
    3208        if not self._match(TokenType.GROUPING_SETS):
    3209            return None
    3210
    3211        return self._parse_wrapped_csv(self._parse_grouping_set)
    3212
    3213    def _parse_grouping_set(self) -> t.Optional[exp.Expression]:
    3214        if self._match(TokenType.L_PAREN):
    3215            grouping_set = self._parse_csv(self._parse_column)
    3216            self._match_r_paren()
    3217            return self.expression(exp.Tuple, expressions=grouping_set)
    3218
    3219        return self._parse_column()
    3220
    3221    def _parse_having(self, skip_having_token: bool = False) -> t.Optional[exp.Having]:
    3222        if not skip_having_token and not self._match(TokenType.HAVING):
    3223            return None
    3224        return self.expression(exp.Having, this=self._parse_conjunction())
    3225
    3226    def _parse_qualify(self) -> t.Optional[exp.Qualify]:
    3227        if not self._match(TokenType.QUALIFY):
    3228            return None
    3229        return self.expression(exp.Qualify, this=self._parse_conjunction())
    3230
    3231    def _parse_connect(self, skip_start_token: bool = False) -> t.Optional[exp.Connect]:
    3232        if skip_start_token:
    3233            start = None
    3234        elif self._match(TokenType.START_WITH):
    3235            start = self._parse_conjunction()
    3236        else:
    3237            return None
    3238
    3239        self._match(TokenType.CONNECT_BY)
    3240        self.NO_PAREN_FUNCTION_PARSERS["PRIOR"] = lambda self: self.expression(
    3241            exp.Prior, this=self._parse_bitwise()
    3242        )
    3243        connect = self._parse_conjunction()
    3244        self.NO_PAREN_FUNCTION_PARSERS.pop("PRIOR")
    3245
    3246        if not start and self._match(TokenType.START_WITH):
    3247            start = self._parse_conjunction()
    3248
    3249        return self.expression(exp.Connect, start=start, connect=connect)
    3250
    3251    def _parse_name_as_expression(self) -> exp.Alias:
    3252        return self.expression(
    3253            exp.Alias,
    3254            alias=self._parse_id_var(any_token=True),
    3255            this=self._match(TokenType.ALIAS) and self._parse_conjunction(),
    3256        )
    3257
    3258    def _parse_interpolate(self) -> t.Optional[t.List[exp.Expression]]:
    3259        if self._match_text_seq("INTERPOLATE"):
    3260            return self._parse_wrapped_csv(self._parse_name_as_expression)
    3261        return None
    3262
    3263    def _parse_order(
    3264        self, this: t.Optional[exp.Expression] = None, skip_order_token: bool = False
    3265    ) -> t.Optional[exp.Expression]:
    3266        siblings = None
    3267        if not skip_order_token and not self._match(TokenType.ORDER_BY):
    3268            if not self._match(TokenType.ORDER_SIBLINGS_BY):
    3269                return this
    3270
    3271            siblings = True
    3272
    3273        return self.expression(
    3274            exp.Order,
    3275            this=this,
    3276            expressions=self._parse_csv(self._parse_ordered),
    3277            interpolate=self._parse_interpolate(),
    3278            siblings=siblings,
    3279        )
    3280
    3281    def _parse_sort(self, exp_class: t.Type[E], token: TokenType) -> t.Optional[E]:
    3282        if not self._match(token):
    3283            return None
    3284        return self.expression(exp_class, expressions=self._parse_csv(self._parse_ordered))
    3285
    3286    def _parse_ordered(self, parse_method: t.Optional[t.Callable] = None) -> exp.Ordered:
    3287        this = parse_method() if parse_method else self._parse_conjunction()
    3288
    3289        asc = self._match(TokenType.ASC)
    3290        desc = self._match(TokenType.DESC) or (asc and False)
    3291
    3292        is_nulls_first = self._match_text_seq("NULLS", "FIRST")
    3293        is_nulls_last = self._match_text_seq("NULLS", "LAST")
    3294
    3295        nulls_first = is_nulls_first or False
    3296        explicitly_null_ordered = is_nulls_first or is_nulls_last
    3297
    3298        if (
    3299            not explicitly_null_ordered
    3300            and (
    3301                (not desc and self.dialect.NULL_ORDERING == "nulls_are_small")
    3302                or (desc and self.dialect.NULL_ORDERING != "nulls_are_small")
    3303            )
    3304            and self.dialect.NULL_ORDERING != "nulls_are_last"
    3305        ):
    3306            nulls_first = True
    3307
    3308        if self._match_text_seq("WITH", "FILL"):
    3309            with_fill = self.expression(
    3310                exp.WithFill,
    3311                **{  # type: ignore
    3312                    "from": self._match(TokenType.FROM) and self._parse_bitwise(),
    3313                    "to": self._match_text_seq("TO") and self._parse_bitwise(),
    3314                    "step": self._match_text_seq("STEP") and self._parse_bitwise(),
    3315                },
    3316            )
    3317        else:
    3318            with_fill = None
    3319
    3320        return self.expression(
    3321            exp.Ordered, this=this, desc=desc, nulls_first=nulls_first, with_fill=with_fill
    3322        )
    3323
    3324    def _parse_limit(
    3325        self, this: t.Optional[exp.Expression] = None, top: bool = False
    3326    ) -> t.Optional[exp.Expression]:
    3327        if self._match(TokenType.TOP if top else TokenType.LIMIT):
    3328            comments = self._prev_comments
    3329            if top:
    3330                limit_paren = self._match(TokenType.L_PAREN)
    3331                expression = self._parse_term() if limit_paren else self._parse_number()
    3332
    3333                if limit_paren:
    3334                    self._match_r_paren()
    3335            else:
    3336                expression = self._parse_term()
    3337
    3338            if self._match(TokenType.COMMA):
    3339                offset = expression
    3340                expression = self._parse_term()
    3341            else:
    3342                offset = None
    3343
    3344            limit_exp = self.expression(
    3345                exp.Limit, this=this, expression=expression, offset=offset, comments=comments
    3346            )
    3347
    3348            return limit_exp
    3349
    3350        if self._match(TokenType.FETCH):
    3351            direction = self._match_set((TokenType.FIRST, TokenType.NEXT))
    3352            direction = self._prev.text.upper() if direction else "FIRST"
    3353
    3354            count = self._parse_field(tokens=self.FETCH_TOKENS)
    3355            percent = self._match(TokenType.PERCENT)
    3356
    3357            self._match_set((TokenType.ROW, TokenType.ROWS))
    3358
    3359            only = self._match_text_seq("ONLY")
    3360            with_ties = self._match_text_seq("WITH", "TIES")
    3361
    3362            if only and with_ties:
    3363                self.raise_error("Cannot specify both ONLY and WITH TIES in FETCH clause")
    3364
    3365            return self.expression(
    3366                exp.Fetch,
    3367                direction=direction,
    3368                count=count,
    3369                percent=percent,
    3370                with_ties=with_ties,
    3371            )
    3372
    3373        return this
    3374
    3375    def _parse_offset(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
    3376        if not self._match(TokenType.OFFSET):
    3377            return this
    3378
    3379        count = self._parse_term()
    3380        self._match_set((TokenType.ROW, TokenType.ROWS))
    3381        return self.expression(exp.Offset, this=this, expression=count)
    3382
    3383    def _parse_locks(self) -> t.List[exp.Lock]:
    3384        locks = []
    3385        while True:
    3386            if self._match_text_seq("FOR", "UPDATE"):
    3387                update = True
    3388            elif self._match_text_seq("FOR", "SHARE") or self._match_text_seq(
    3389                "LOCK", "IN", "SHARE", "MODE"
    3390            ):
    3391                update = False
    3392            else:
    3393                break
    3394
    3395            expressions = None
    3396            if self._match_text_seq("OF"):
    3397                expressions = self._parse_csv(lambda: self._parse_table(schema=True))
    3398
    3399            wait: t.Optional[bool | exp.Expression] = None
    3400            if self._match_text_seq("NOWAIT"):
    3401                wait = True
    3402            elif self._match_text_seq("WAIT"):
    3403                wait = self._parse_primary()
    3404            elif self._match_text_seq("SKIP", "LOCKED"):
    3405                wait = False
    3406
    3407            locks.append(
    3408                self.expression(exp.Lock, update=update, expressions=expressions, wait=wait)
    3409            )
    3410
    3411        return locks
    3412
    3413    def _parse_set_operations(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    3414        while this and self._match_set(self.SET_OPERATIONS):
    3415            token_type = self._prev.token_type
    3416
    3417            if token_type == TokenType.UNION:
    3418                operation = exp.Union
    3419            elif token_type == TokenType.EXCEPT:
    3420                operation = exp.Except
    3421            else:
    3422                operation = exp.Intersect
    3423
    3424            comments = self._prev.comments
    3425            distinct = self._match(TokenType.DISTINCT) or not self._match(TokenType.ALL)
    3426            by_name = self._match_text_seq("BY", "NAME")
    3427            expression = self._parse_select(nested=True, parse_set_operation=False)
    3428
    3429            this = self.expression(
    3430                operation,
    3431                comments=comments,
    3432                this=this,
    3433                distinct=distinct,
    3434                by_name=by_name,
    3435                expression=expression,
    3436            )
    3437
    3438        if isinstance(this, exp.Union) and self.MODIFIERS_ATTACHED_TO_UNION:
    3439            expression = this.expression
    3440
    3441            if expression:
    3442                for arg in self.UNION_MODIFIERS:
    3443                    expr = expression.args.get(arg)
    3444                    if expr:
    3445                        this.set(arg, expr.pop())
    3446
    3447        return this
    3448
    3449    def _parse_expression(self) -> t.Optional[exp.Expression]:
    3450        return self._parse_alias(self._parse_conjunction())
    3451
    3452    def _parse_conjunction(self) -> t.Optional[exp.Expression]:
    3453        return self._parse_tokens(self._parse_equality, self.CONJUNCTION)
    3454
    3455    def _parse_equality(self) -> t.Optional[exp.Expression]:
    3456        return self._parse_tokens(self._parse_comparison, self.EQUALITY)
    3457
    3458    def _parse_comparison(self) -> t.Optional[exp.Expression]:
    3459        return self._parse_tokens(self._parse_range, self.COMPARISON)
    3460
    3461    def _parse_range(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
    3462        this = this or self._parse_bitwise()
    3463        negate = self._match(TokenType.NOT)
    3464
    3465        if self._match_set(self.RANGE_PARSERS):
    3466            expression = self.RANGE_PARSERS[self._prev.token_type](self, this)
    3467            if not expression:
    3468                return this
    3469
    3470            this = expression
    3471        elif self._match(TokenType.ISNULL):
    3472            this = self.expression(exp.Is, this=this, expression=exp.Null())
    3473
    3474        # Postgres supports ISNULL and NOTNULL for conditions.
    3475        # https://blog.andreiavram.ro/postgresql-null-composite-type/
    3476        if self._match(TokenType.NOTNULL):
    3477            this = self.expression(exp.Is, this=this, expression=exp.Null())
    3478            this = self.expression(exp.Not, this=this)
    3479
    3480        if negate:
    3481            this = self.expression(exp.Not, this=this)
    3482
    3483        if self._match(TokenType.IS):
    3484            this = self._parse_is(this)
    3485
    3486        return this
    3487
    3488    def _parse_is(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    3489        index = self._index - 1
    3490        negate = self._match(TokenType.NOT)
    3491
    3492        if self._match_text_seq("DISTINCT", "FROM"):
    3493            klass = exp.NullSafeEQ if negate else exp.NullSafeNEQ
    3494            return self.expression(klass, this=this, expression=self._parse_conjunction())
    3495
    3496        expression = self._parse_null() or self._parse_boolean()
    3497        if not expression:
    3498            self._retreat(index)
    3499            return None
    3500
    3501        this = self.expression(exp.Is, this=this, expression=expression)
    3502        return self.expression(exp.Not, this=this) if negate else this
    3503
    3504    def _parse_in(self, this: t.Optional[exp.Expression], alias: bool = False) -> exp.In:
    3505        unnest = self._parse_unnest(with_alias=False)
    3506        if unnest:
    3507            this = self.expression(exp.In, this=this, unnest=unnest)
    3508        elif self._match_set((TokenType.L_PAREN, TokenType.L_BRACKET)):
    3509            matched_l_paren = self._prev.token_type == TokenType.L_PAREN
    3510            expressions = self._parse_csv(lambda: self._parse_select_or_expression(alias=alias))
    3511
    3512            if len(expressions) == 1 and isinstance(expressions[0], exp.Subqueryable):
    3513                this = self.expression(exp.In, this=this, query=expressions[0])
    3514            else:
    3515                this = self.expression(exp.In, this=this, expressions=expressions)
    3516
    3517            if matched_l_paren:
    3518                self._match_r_paren(this)
    3519            elif not self._match(TokenType.R_BRACKET, expression=this):
    3520                self.raise_error("Expecting ]")
    3521        else:
    3522            this = self.expression(exp.In, this=this, field=self._parse_field())
    3523
    3524        return this
    3525
    3526    def _parse_between(self, this: t.Optional[exp.Expression]) -> exp.Between:
    3527        low = self._parse_bitwise()
    3528        self._match(TokenType.AND)
    3529        high = self._parse_bitwise()
    3530        return self.expression(exp.Between, this=this, low=low, high=high)
    3531
    3532    def _parse_escape(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    3533        if not self._match(TokenType.ESCAPE):
    3534            return this
    3535        return self.expression(exp.Escape, this=this, expression=self._parse_string())
    3536
    3537    def _parse_interval(self, match_interval: bool = True) -> t.Optional[exp.Interval]:
    3538        index = self._index
    3539
    3540        if not self._match(TokenType.INTERVAL) and match_interval:
    3541            return None
    3542
    3543        if self._match(TokenType.STRING, advance=False):
    3544            this = self._parse_primary()
    3545        else:
    3546            this = self._parse_term()
    3547
    3548        if not this or (
    3549            isinstance(this, exp.Column)
    3550            and not this.table
    3551            and not this.this.quoted
    3552            and this.name.upper() == "IS"
    3553        ):
    3554            self._retreat(index)
    3555            return None
    3556
    3557        unit = self._parse_function() or (
    3558            not self._match(TokenType.ALIAS, advance=False)
    3559            and self._parse_var(any_token=True, upper=True)
    3560        )
    3561
    3562        # Most dialects support, e.g., the form INTERVAL '5' day, thus we try to parse
    3563        # each INTERVAL expression into this canonical form so it's easy to transpile
    3564        if this and this.is_number:
    3565            this = exp.Literal.string(this.name)
    3566        elif this and this.is_string:
    3567            parts = this.name.split()
    3568
    3569            if len(parts) == 2:
    3570                if unit:
    3571                    # This is not actually a unit, it's something else (e.g. a "window side")
    3572                    unit = None
    3573                    self._retreat(self._index - 1)
    3574
    3575                this = exp.Literal.string(parts[0])
    3576                unit = self.expression(exp.Var, this=parts[1].upper())
    3577
    3578        return self.expression(exp.Interval, this=this, unit=unit)
    3579
    3580    def _parse_bitwise(self) -> t.Optional[exp.Expression]:
    3581        this = self._parse_term()
    3582
    3583        while True:
    3584            if self._match_set(self.BITWISE):
    3585                this = self.expression(
    3586                    self.BITWISE[self._prev.token_type],
    3587                    this=this,
    3588                    expression=self._parse_term(),
    3589                )
    3590            elif self.dialect.DPIPE_IS_STRING_CONCAT and self._match(TokenType.DPIPE):
    3591                this = self.expression(
    3592                    exp.DPipe,
    3593                    this=this,
    3594                    expression=self._parse_term(),
    3595                    safe=not self.dialect.STRICT_STRING_CONCAT,
    3596                )
    3597            elif self._match(TokenType.DQMARK):
    3598                this = self.expression(exp.Coalesce, this=this, expressions=self._parse_term())
    3599            elif self._match_pair(TokenType.LT, TokenType.LT):
    3600                this = self.expression(
    3601                    exp.BitwiseLeftShift, this=this, expression=self._parse_term()
    3602                )
    3603            elif self._match_pair(TokenType.GT, TokenType.GT):
    3604                this = self.expression(
    3605                    exp.BitwiseRightShift, this=this, expression=self._parse_term()
    3606                )
    3607            else:
    3608                break
    3609
    3610        return this
    3611
    3612    def _parse_term(self) -> t.Optional[exp.Expression]:
    3613        return self._parse_tokens(self._parse_factor, self.TERM)
    3614
    3615    def _parse_factor(self) -> t.Optional[exp.Expression]:
    3616        parse_method = self._parse_exponent if self.EXPONENT else self._parse_unary
    3617        this = parse_method()
    3618
    3619        while self._match_set(self.FACTOR):
    3620            this = self.expression(
    3621                self.FACTOR[self._prev.token_type],
    3622                this=this,
    3623                comments=self._prev_comments,
    3624                expression=parse_method(),
    3625            )
    3626            if isinstance(this, exp.Div):
    3627                this.args["typed"] = self.dialect.TYPED_DIVISION
    3628                this.args["safe"] = self.dialect.SAFE_DIVISION
    3629
    3630        return this
    3631
    3632    def _parse_exponent(self) -> t.Optional[exp.Expression]:
    3633        return self._parse_tokens(self._parse_unary, self.EXPONENT)
    3634
    3635    def _parse_unary(self) -> t.Optional[exp.Expression]:
    3636        if self._match_set(self.UNARY_PARSERS):
    3637            return self.UNARY_PARSERS[self._prev.token_type](self)
    3638        return self._parse_at_time_zone(self._parse_type())
    3639
    3640    def _parse_type(self, parse_interval: bool = True) -> t.Optional[exp.Expression]:
    3641        interval = parse_interval and self._parse_interval()
    3642        if interval:
    3643            # Convert INTERVAL 'val_1' unit_1 ... 'val_n' unit_n into a sum of intervals
    3644            while self._match_set((TokenType.STRING, TokenType.NUMBER), advance=False):
    3645                interval = self.expression(  # type: ignore
    3646                    exp.Add, this=interval, expression=self._parse_interval(match_interval=False)
    3647                )
    3648
    3649            return interval
    3650
    3651        index = self._index
    3652        data_type = self._parse_types(check_func=True, allow_identifiers=False)
    3653        this = self._parse_column()
    3654
    3655        if data_type:
    3656            if isinstance(this, exp.Literal):
    3657                parser = self.TYPE_LITERAL_PARSERS.get(data_type.this)
    3658                if parser:
    3659                    return parser(self, this, data_type)
    3660                return self.expression(exp.Cast, this=this, to=data_type)
    3661            if not data_type.expressions:
    3662                self._retreat(index)
    3663                return self._parse_column()
    3664            return self._parse_column_ops(data_type)
    3665
    3666        return this and self._parse_column_ops(this)
    3667
    3668    def _parse_type_size(self) -> t.Optional[exp.DataTypeParam]:
    3669        this = self._parse_type()
    3670        if not this:
    3671            return None
    3672
    3673        return self.expression(
    3674            exp.DataTypeParam, this=this, expression=self._parse_var(any_token=True)
    3675        )
    3676
    3677    def _parse_types(
    3678        self, check_func: bool = False, schema: bool = False, allow_identifiers: bool = True
    3679    ) -> t.Optional[exp.Expression]:
    3680        index = self._index
    3681
    3682        prefix = self._match_text_seq("SYSUDTLIB", ".")
    3683
    3684        if not self._match_set(self.TYPE_TOKENS):
    3685            identifier = allow_identifiers and self._parse_id_var(
    3686                any_token=False, tokens=(TokenType.VAR,)
    3687            )
    3688            if identifier:
    3689                tokens = self.dialect.tokenize(identifier.name)
    3690
    3691                if len(tokens) != 1:
    3692                    self.raise_error("Unexpected identifier", self._prev)
    3693
    3694                if tokens[0].token_type in self.TYPE_TOKENS:
    3695                    self._prev = tokens[0]
    3696                elif self.dialect.SUPPORTS_USER_DEFINED_TYPES:
    3697                    type_name = identifier.name
    3698
    3699                    while self._match(TokenType.DOT):
    3700                        type_name = f"{type_name}.{self._advance_any() and self._prev.text}"
    3701
    3702                    return exp.DataType.build(type_name, udt=True)
    3703                else:
    3704                    self._retreat(self._index - 1)
    3705                    return None
    3706            else:
    3707                return None
    3708
    3709        type_token = self._prev.token_type
    3710
    3711        if type_token == TokenType.PSEUDO_TYPE:
    3712            return self.expression(exp.PseudoType, this=self._prev.text.upper())
    3713
    3714        if type_token == TokenType.OBJECT_IDENTIFIER:
    3715            return self.expression(exp.ObjectIdentifier, this=self._prev.text.upper())
    3716
    3717        nested = type_token in self.NESTED_TYPE_TOKENS
    3718        is_struct = type_token in self.STRUCT_TYPE_TOKENS
    3719        is_aggregate = type_token in self.AGGREGATE_TYPE_TOKENS
    3720        expressions = None
    3721        maybe_func = False
    3722
    3723        if self._match(TokenType.L_PAREN):
    3724            if is_struct:
    3725                expressions = self._parse_csv(self._parse_struct_types)
    3726            elif nested:
    3727                expressions = self._parse_csv(
    3728                    lambda: self._parse_types(
    3729                        check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
    3730                    )
    3731                )
    3732            elif type_token in self.ENUM_TYPE_TOKENS:
    3733                expressions = self._parse_csv(self._parse_equality)
    3734            elif is_aggregate:
    3735                func_or_ident = self._parse_function(anonymous=True) or self._parse_id_var(
    3736                    any_token=False, tokens=(TokenType.VAR,)
    3737                )
    3738                if not func_or_ident or not self._match(TokenType.COMMA):
    3739                    return None
    3740                expressions = self._parse_csv(
    3741                    lambda: self._parse_types(
    3742                        check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
    3743                    )
    3744                )
    3745                expressions.insert(0, func_or_ident)
    3746            else:
    3747                expressions = self._parse_csv(self._parse_type_size)
    3748
    3749            if not expressions or not self._match(TokenType.R_PAREN):
    3750                self._retreat(index)
    3751                return None
    3752
    3753            maybe_func = True
    3754
    3755        this: t.Optional[exp.Expression] = None
    3756        values: t.Optional[t.List[exp.Expression]] = None
    3757
    3758        if nested and self._match(TokenType.LT):
    3759            if is_struct:
    3760                expressions = self._parse_csv(lambda: self._parse_struct_types(type_required=True))
    3761            else:
    3762                expressions = self._parse_csv(
    3763                    lambda: self._parse_types(
    3764                        check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
    3765                    )
    3766                )
    3767
    3768            if not self._match(TokenType.GT):
    3769                self.raise_error("Expecting >")
    3770
    3771            if self._match_set((TokenType.L_BRACKET, TokenType.L_PAREN)):
    3772                values = self._parse_csv(self._parse_conjunction)
    3773                self._match_set((TokenType.R_BRACKET, TokenType.R_PAREN))
    3774
    3775        if type_token in self.TIMESTAMPS:
    3776            if self._match_text_seq("WITH", "TIME", "ZONE"):
    3777                maybe_func = False
    3778                tz_type = (
    3779                    exp.DataType.Type.TIMETZ
    3780                    if type_token in self.TIMES
    3781                    else exp.DataType.Type.TIMESTAMPTZ
    3782                )
    3783                this = exp.DataType(this=tz_type, expressions=expressions)
    3784            elif self._match_text_seq("WITH", "LOCAL", "TIME", "ZONE"):
    3785                maybe_func = False
    3786                this = exp.DataType(this=exp.DataType.Type.TIMESTAMPLTZ, expressions=expressions)
    3787            elif self._match_text_seq("WITHOUT", "TIME", "ZONE"):
    3788                maybe_func = False
    3789        elif type_token == TokenType.INTERVAL:
    3790            unit = self._parse_var()
    3791
    3792            if self._match_text_seq("TO"):
    3793                span = [exp.IntervalSpan(this=unit, expression=self._parse_var())]
    3794            else:
    3795                span = None
    3796
    3797            if span or not unit:
    3798                this = self.expression(
    3799                    exp.DataType, this=exp.DataType.Type.INTERVAL, expressions=span
    3800                )
    3801            else:
    3802                this = self.expression(exp.DataType, this=self.expression(exp.Interval, unit=unit))
    3803
    3804        if maybe_func and check_func:
    3805            index2 = self._index
    3806            peek = self._parse_string()
    3807
    3808            if not peek:
    3809                self._retreat(index)
    3810                return None
    3811
    3812            self._retreat(index2)
    3813
    3814        if not this:
    3815            if self._match_text_seq("UNSIGNED"):
    3816                unsigned_type_token = self.SIGNED_TO_UNSIGNED_TYPE_TOKEN.get(type_token)
    3817                if not unsigned_type_token:
    3818                    self.raise_error(f"Cannot convert {type_token.value} to unsigned.")
    3819
    3820                type_token = unsigned_type_token or type_token
    3821
    3822            this = exp.DataType(
    3823                this=exp.DataType.Type[type_token.value],
    3824                expressions=expressions,
    3825                nested=nested,
    3826                values=values,
    3827                prefix=prefix,
    3828            )
    3829
    3830        while self._match_pair(TokenType.L_BRACKET, TokenType.R_BRACKET):
    3831            this = exp.DataType(this=exp.DataType.Type.ARRAY, expressions=[this], nested=True)
    3832
    3833        return this
    3834
    3835    def _parse_struct_types(self, type_required: bool = False) -> t.Optional[exp.Expression]:
    3836        index = self._index
    3837        this = self._parse_type(parse_interval=False) or self._parse_id_var()
    3838        self._match(TokenType.COLON)
    3839        column_def = self._parse_column_def(this)
    3840
    3841        if type_required and (
    3842            (isinstance(this, exp.Column) and this.this is column_def) or this is column_def
    3843        ):
    3844            self._retreat(index)
    3845            return self._parse_types()
    3846
    3847        return column_def
    3848
    3849    def _parse_at_time_zone(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    3850        if not self._match_text_seq("AT", "TIME", "ZONE"):
    3851            return this
    3852        return self.expression(exp.AtTimeZone, this=this, zone=self._parse_unary())
    3853
    3854    def _parse_column(self) -> t.Optional[exp.Expression]:
    3855        this = self._parse_field()
    3856        if isinstance(this, exp.Identifier):
    3857            this = self.expression(exp.Column, this=this)
    3858        elif not this:
    3859            return self._parse_bracket(this)
    3860        return self._parse_column_ops(this)
    3861
    3862    def _parse_column_ops(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    3863        this = self._parse_bracket(this)
    3864
    3865        while self._match_set(self.COLUMN_OPERATORS):
    3866            op_token = self._prev.token_type
    3867            op = self.COLUMN_OPERATORS.get(op_token)
    3868
    3869            if op_token == TokenType.DCOLON:
    3870                field = self._parse_types()
    3871                if not field:
    3872                    self.raise_error("Expected type")
    3873            elif op and self._curr:
    3874                self._advance()
    3875                value = self._prev.text
    3876                field = (
    3877                    exp.Literal.number(value)
    3878                    if self._prev.token_type == TokenType.NUMBER
    3879                    else exp.Literal.string(value)
    3880                )
    3881            else:
    3882                field = self._parse_field(anonymous_func=True, any_token=True)
    3883
    3884            if isinstance(field, exp.Func):
    3885                # bigquery allows function calls like x.y.count(...)
    3886                # SAFE.SUBSTR(...)
    3887                # https://cloud.google.com/bigquery/docs/reference/standard-sql/functions-reference#function_call_rules
    3888                this = self._replace_columns_with_dots(this)
    3889
    3890            if op:
    3891                this = op(self, this, field)
    3892            elif isinstance(this, exp.Column) and not this.args.get("catalog"):
    3893                this = self.expression(
    3894                    exp.Column,
    3895                    this=field,
    3896                    table=this.this,
    3897                    db=this.args.get("table"),
    3898                    catalog=this.args.get("db"),
    3899                )
    3900            else:
    3901                this = self.expression(exp.Dot, this=this, expression=field)
    3902            this = self._parse_bracket(this)
    3903        return this
    3904
    3905    def _parse_primary(self) -> t.Optional[exp.Expression]:
    3906        if self._match_set(self.PRIMARY_PARSERS):
    3907            token_type = self._prev.token_type
    3908            primary = self.PRIMARY_PARSERS[token_type](self, self._prev)
    3909
    3910            if token_type == TokenType.STRING:
    3911                expressions = [primary]
    3912                while self._match(TokenType.STRING):
    3913                    expressions.append(exp.Literal.string(self._prev.text))
    3914
    3915                if len(expressions) > 1:
    3916                    return self.expression(exp.Concat, expressions=expressions)
    3917
    3918            return primary
    3919
    3920        if self._match_pair(TokenType.DOT, TokenType.NUMBER):
    3921            return exp.Literal.number(f"0.{self._prev.text}")
    3922
    3923        if self._match(TokenType.L_PAREN):
    3924            comments = self._prev_comments
    3925            query = self._parse_select()
    3926
    3927            if query:
    3928                expressions = [query]
    3929            else:
    3930                expressions = self._parse_expressions()
    3931
    3932            this = self._parse_query_modifiers(seq_get(expressions, 0))
    3933
    3934            if isinstance(this, exp.Subqueryable):
    3935                this = self._parse_set_operations(
    3936                    self._parse_subquery(this=this, parse_alias=False)
    3937                )
    3938            elif len(expressions) > 1:
    3939                this = self.expression(exp.Tuple, expressions=expressions)
    3940            else:
    3941                this = self.expression(exp.Paren, this=self._parse_set_operations(this))
    3942
    3943            if this:
    3944                this.add_comments(comments)
    3945
    3946            self._match_r_paren(expression=this)
    3947            return this
    3948
    3949        return None
    3950
    3951    def _parse_field(
    3952        self,
    3953        any_token: bool = False,
    3954        tokens: t.Optional[t.Collection[TokenType]] = None,
    3955        anonymous_func: bool = False,
    3956    ) -> t.Optional[exp.Expression]:
    3957        return (
    3958            self._parse_primary()
    3959            or self._parse_function(anonymous=anonymous_func)
    3960            or self._parse_id_var(any_token=any_token, tokens=tokens)
    3961        )
    3962
    3963    def _parse_function(
    3964        self,
    3965        functions: t.Optional[t.Dict[str, t.Callable]] = None,
    3966        anonymous: bool = False,
    3967        optional_parens: bool = True,
    3968    ) -> t.Optional[exp.Expression]:
    3969        # This allows us to also parse {fn <function>} syntax (Snowflake, MySQL support this)
    3970        # See: https://community.snowflake.com/s/article/SQL-Escape-Sequences
    3971        fn_syntax = False
    3972        if (
    3973            self._match(TokenType.L_BRACE, advance=False)
    3974            and self._next
    3975            and self._next.text.upper() == "FN"
    3976        ):
    3977            self._advance(2)
    3978            fn_syntax = True
    3979
    3980        func = self._parse_function_call(
    3981            functions=functions, anonymous=anonymous, optional_parens=optional_parens
    3982        )
    3983
    3984        if fn_syntax:
    3985            self._match(TokenType.R_BRACE)
    3986
    3987        return func
    3988
    3989    def _parse_function_call(
    3990        self,
    3991        functions: t.Optional[t.Dict[str, t.Callable]] = None,
    3992        anonymous: bool = False,
    3993        optional_parens: bool = True,
    3994    ) -> t.Optional[exp.Expression]:
    3995        if not self._curr:
    3996            return None
    3997
    3998        comments = self._curr.comments
    3999        token_type = self._curr.token_type
    4000        this = self._curr.text
    4001        upper = this.upper()
    4002
    4003        parser = self.NO_PAREN_FUNCTION_PARSERS.get(upper)
    4004        if optional_parens and parser and token_type not in self.INVALID_FUNC_NAME_TOKENS:
    4005            self._advance()
    4006            return parser(self)
    4007
    4008        if not self._next or self._next.token_type != TokenType.L_PAREN:
    4009            if optional_parens and token_type in self.NO_PAREN_FUNCTIONS:
    4010                self._advance()
    4011                return self.expression(self.NO_PAREN_FUNCTIONS[token_type])
    4012
    4013            return None
    4014
    4015        if token_type not in self.FUNC_TOKENS:
    4016            return None
    4017
    4018        self._advance(2)
    4019
    4020        parser = self.FUNCTION_PARSERS.get(upper)
    4021        if parser and not anonymous:
    4022            this = parser(self)
    4023        else:
    4024            subquery_predicate = self.SUBQUERY_PREDICATES.get(token_type)
    4025
    4026            if subquery_predicate and self._curr.token_type in (TokenType.SELECT, TokenType.WITH):
    4027                this = self.expression(subquery_predicate, this=self._parse_select())
    4028                self._match_r_paren()
    4029                return this
    4030
    4031            if functions is None:
    4032                functions = self.FUNCTIONS
    4033
    4034            function = functions.get(upper)
    4035
    4036            alias = upper in self.FUNCTIONS_WITH_ALIASED_ARGS
    4037            args = self._parse_csv(lambda: self._parse_lambda(alias=alias))
    4038
    4039            if function and not anonymous:
    4040                if "dialect" in function.__code__.co_varnames:
    4041                    func = function(args, dialect=self.dialect)
    4042                else:
    4043                    func = function(args)
    4044
    4045                func = self.validate_expression(func, args)
    4046                if not self.dialect.NORMALIZE_FUNCTIONS:
    4047                    func.meta["name"] = this
    4048
    4049                this = func
    4050            else:
    4051                this = self.expression(exp.Anonymous, this=this, expressions=args)
    4052
    4053        if isinstance(this, exp.Expression):
    4054            this.add_comments(comments)
    4055
    4056        self._match_r_paren(this)
    4057        return self._parse_window(this)
    4058
    4059    def _parse_function_parameter(self) -> t.Optional[exp.Expression]:
    4060        return self._parse_column_def(self._parse_id_var())
    4061
    4062    def _parse_user_defined_function(
    4063        self, kind: t.Optional[TokenType] = None
    4064    ) -> t.Optional[exp.Expression]:
    4065        this = self._parse_id_var()
    4066
    4067        while self._match(TokenType.DOT):
    4068            this = self.expression(exp.Dot, this=this, expression=self._parse_id_var())
    4069
    4070        if not self._match(TokenType.L_PAREN):
    4071            return this
    4072
    4073        expressions = self._parse_csv(self._parse_function_parameter)
    4074        self._match_r_paren()
    4075        return self.expression(
    4076            exp.UserDefinedFunction, this=this, expressions=expressions, wrapped=True
    4077        )
    4078
    4079    def _parse_introducer(self, token: Token) -> exp.Introducer | exp.Identifier:
    4080        literal = self._parse_primary()
    4081        if literal:
    4082            return self.expression(exp.Introducer, this=token.text, expression=literal)
    4083
    4084        return self.expression(exp.Identifier, this=token.text)
    4085
    4086    def _parse_session_parameter(self) -> exp.SessionParameter:
    4087        kind = None
    4088        this = self._parse_id_var() or self._parse_primary()
    4089
    4090        if this and self._match(TokenType.DOT):
    4091            kind = this.name
    4092            this = self._parse_var() or self._parse_primary()
    4093
    4094        return self.expression(exp.SessionParameter, this=this, kind=kind)
    4095
    4096    def _parse_lambda(self, alias: bool = False) -> t.Optional[exp.Expression]:
    4097        index = self._index
    4098
    4099        if self._match(TokenType.L_PAREN):
    4100            expressions = t.cast(
    4101                t.List[t.Optional[exp.Expression]], self._parse_csv(self._parse_id_var)
    4102            )
    4103
    4104            if not self._match(TokenType.R_PAREN):
    4105                self._retreat(index)
    4106        else:
    4107            expressions = [self._parse_id_var()]
    4108
    4109        if self._match_set(self.LAMBDAS):
    4110            return self.LAMBDAS[self._prev.token_type](self, expressions)
    4111
    4112        self._retreat(index)
    4113
    4114        this: t.Optional[exp.Expression]
    4115
    4116        if self._match(TokenType.DISTINCT):
    4117            this = self.expression(
    4118                exp.Distinct, expressions=self._parse_csv(self._parse_conjunction)
    4119            )
    4120        else:
    4121            this = self._parse_select_or_expression(alias=alias)
    4122
    4123        return self._parse_limit(self._parse_order(self._parse_respect_or_ignore_nulls(this)))
    4124
    4125    def _parse_schema(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
    4126        index = self._index
    4127
    4128        if not self.errors:
    4129            try:
    4130                if self._parse_select(nested=True):
    4131                    return this
    4132            except ParseError:
    4133                pass
    4134            finally:
    4135                self.errors.clear()
    4136                self._retreat(index)
    4137
    4138        if not self._match(TokenType.L_PAREN):
    4139            return this
    4140
    4141        args = self._parse_csv(lambda: self._parse_constraint() or self._parse_field_def())
    4142
    4143        self._match_r_paren()
    4144        return self.expression(exp.Schema, this=this, expressions=args)
    4145
    4146    def _parse_field_def(self) -> t.Optional[exp.Expression]:
    4147        return self._parse_column_def(self._parse_field(any_token=True))
    4148
    4149    def _parse_column_def(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    4150        # column defs are not really columns, they're identifiers
    4151        if isinstance(this, exp.Column):
    4152            this = this.this
    4153
    4154        kind = self._parse_types(schema=True)
    4155
    4156        if self._match_text_seq("FOR", "ORDINALITY"):
    4157            return self.expression(exp.ColumnDef, this=this, ordinality=True)
    4158
    4159        constraints: t.List[exp.Expression] = []
    4160
    4161        if not kind and self._match(TokenType.ALIAS):
    4162            constraints.append(
    4163                self.expression(
    4164                    exp.ComputedColumnConstraint,
    4165                    this=self._parse_conjunction(),
    4166                    persisted=self._match_text_seq("PERSISTED"),
    4167                    not_null=self._match_pair(TokenType.NOT, TokenType.NULL),
    4168                )
    4169            )
    4170        elif kind and self._match_pair(TokenType.ALIAS, TokenType.L_PAREN, advance=False):
    4171            self._match(TokenType.ALIAS)
    4172            constraints.append(
    4173                self.expression(exp.TransformColumnConstraint, this=self._parse_field())
    4174            )
    4175
    4176        while True:
    4177            constraint = self._parse_column_constraint()
    4178            if not constraint:
    4179                break
    4180            constraints.append(constraint)
    4181
    4182        if not kind and not constraints:
    4183            return this
    4184
    4185        return self.expression(exp.ColumnDef, this=this, kind=kind, constraints=constraints)
    4186
    4187    def _parse_auto_increment(
    4188        self,
    4189    ) -> exp.GeneratedAsIdentityColumnConstraint | exp.AutoIncrementColumnConstraint:
    4190        start = None
    4191        increment = None
    4192
    4193        if self._match(TokenType.L_PAREN, advance=False):
    4194            args = self._parse_wrapped_csv(self._parse_bitwise)
    4195            start = seq_get(args, 0)
    4196            increment = seq_get(args, 1)
    4197        elif self._match_text_seq("START"):
    4198            start = self._parse_bitwise()
    4199            self._match_text_seq("INCREMENT")
    4200            increment = self._parse_bitwise()
    4201
    4202        if start and increment:
    4203            return exp.GeneratedAsIdentityColumnConstraint(start=start, increment=increment)
    4204
    4205        return exp.AutoIncrementColumnConstraint()
    4206
    4207    def _parse_auto_property(self) -> t.Optional[exp.AutoRefreshProperty]:
    4208        if not self._match_text_seq("REFRESH"):
    4209            self._retreat(self._index - 1)
    4210            return None
    4211        return self.expression(exp.AutoRefreshProperty, this=self._parse_var(upper=True))
    4212
    4213    def _parse_compress(self) -> exp.CompressColumnConstraint:
    4214        if self._match(TokenType.L_PAREN, advance=False):
    4215            return self.expression(
    4216                exp.CompressColumnConstraint, this=self._parse_wrapped_csv(self._parse_bitwise)
    4217            )
    4218
    4219        return self.expression(exp.CompressColumnConstraint, this=self._parse_bitwise())
    4220
    4221    def _parse_generated_as_identity(
    4222        self,
    4223    ) -> (
    4224        exp.GeneratedAsIdentityColumnConstraint
    4225        | exp.ComputedColumnConstraint
    4226        | exp.GeneratedAsRowColumnConstraint
    4227    ):
    4228        if self._match_text_seq("BY", "DEFAULT"):
    4229            on_null = self._match_pair(TokenType.ON, TokenType.NULL)
    4230            this = self.expression(
    4231                exp.GeneratedAsIdentityColumnConstraint, this=False, on_null=on_null
    4232            )
    4233        else:
    4234            self._match_text_seq("ALWAYS")
    4235            this = self.expression(exp.GeneratedAsIdentityColumnConstraint, this=True)
    4236
    4237        self._match(TokenType.ALIAS)
    4238
    4239        if self._match_text_seq("ROW"):
    4240            start = self._match_text_seq("START")
    4241            if not start:
    4242                self._match(TokenType.END)
    4243            hidden = self._match_text_seq("HIDDEN")
    4244            return self.expression(exp.GeneratedAsRowColumnConstraint, start=start, hidden=hidden)
    4245
    4246        identity = self._match_text_seq("IDENTITY")
    4247
    4248        if self._match(TokenType.L_PAREN):
    4249            if self._match(TokenType.START_WITH):
    4250                this.set("start", self._parse_bitwise())
    4251            if self._match_text_seq("INCREMENT", "BY"):
    4252                this.set("increment", self._parse_bitwise())
    4253            if self._match_text_seq("MINVALUE"):
    4254                this.set("minvalue", self._parse_bitwise())
    4255            if self._match_text_seq("MAXVALUE"):
    4256                this.set("maxvalue", self._parse_bitwise())
    4257
    4258            if self._match_text_seq("CYCLE"):
    4259                this.set("cycle", True)
    4260            elif self._match_text_seq("NO", "CYCLE"):
    4261                this.set("cycle", False)
    4262
    4263            if not identity:
    4264                this.set("expression", self._parse_bitwise())
    4265            elif not this.args.get("start") and self._match(TokenType.NUMBER, advance=False):
    4266                args = self._parse_csv(self._parse_bitwise)
    4267                this.set("start", seq_get(args, 0))
    4268                this.set("increment", seq_get(args, 1))
    4269
    4270            self._match_r_paren()
    4271
    4272        return this
    4273
    4274    def _parse_inline(self) -> exp.InlineLengthColumnConstraint:
    4275        self._match_text_seq("LENGTH")
    4276        return self.expression(exp.InlineLengthColumnConstraint, this=self._parse_bitwise())
    4277
    4278    def _parse_not_constraint(
    4279        self,
    4280    ) -> t.Optional[exp.Expression]:
    4281        if self._match_text_seq("NULL"):
    4282            return self.expression(exp.NotNullColumnConstraint)
    4283        if self._match_text_seq("CASESPECIFIC"):
    4284            return self.expression(exp.CaseSpecificColumnConstraint, not_=True)
    4285        if self._match_text_seq("FOR", "REPLICATION"):
    4286            return self.expression(exp.NotForReplicationColumnConstraint)
    4287        return None
    4288
    4289    def _parse_column_constraint(self) -> t.Optional[exp.Expression]:
    4290        if self._match(TokenType.CONSTRAINT):
    4291            this = self._parse_id_var()
    4292        else:
    4293            this = None
    4294
    4295        if self._match_texts(self.CONSTRAINT_PARSERS):
    4296            return self.expression(
    4297                exp.ColumnConstraint,
    4298                this=this,
    4299                kind=self.CONSTRAINT_PARSERS[self._prev.text.upper()](self),
    4300            )
    4301
    4302        return this
    4303
    4304    def _parse_constraint(self) -> t.Optional[exp.Expression]:
    4305        if not self._match(TokenType.CONSTRAINT):
    4306            return self._parse_unnamed_constraint(constraints=self.SCHEMA_UNNAMED_CONSTRAINTS)
    4307
    4308        this = self._parse_id_var()
    4309        expressions = []
    4310
    4311        while True:
    4312            constraint = self._parse_unnamed_constraint() or self._parse_function()
    4313            if not constraint:
    4314                break
    4315            expressions.append(constraint)
    4316
    4317        return self.expression(exp.Constraint, this=this, expressions=expressions)
    4318
    4319    def _parse_unnamed_constraint(
    4320        self, constraints: t.Optional[t.Collection[str]] = None
    4321    ) -> t.Optional[exp.Expression]:
    4322        if self._match(TokenType.IDENTIFIER, advance=False) or not self._match_texts(
    4323            constraints or self.CONSTRAINT_PARSERS
    4324        ):
    4325            return None
    4326
    4327        constraint = self._prev.text.upper()
    4328        if constraint not in self.CONSTRAINT_PARSERS:
    4329            self.raise_error(f"No parser found for schema constraint {constraint}.")
    4330
    4331        return self.CONSTRAINT_PARSERS[constraint](self)
    4332
    4333    def _parse_unique(self) -> exp.UniqueColumnConstraint:
    4334        self._match_text_seq("KEY")
    4335        return self.expression(
    4336            exp.UniqueColumnConstraint,
    4337            this=self._parse_schema(self._parse_id_var(any_token=False)),
    4338            index_type=self._match(TokenType.USING) and self._advance_any() and self._prev.text,
    4339        )
    4340
    4341    def _parse_key_constraint_options(self) -> t.List[str]:
    4342        options = []
    4343        while True:
    4344            if not self._curr:
    4345                break
    4346
    4347            if self._match(TokenType.ON):
    4348                action = None
    4349                on = self._advance_any() and self._prev.text
    4350
    4351                if self._match_text_seq("NO", "ACTION"):
    4352                    action = "NO ACTION"
    4353                elif self._match_text_seq("CASCADE"):
    4354                    action = "CASCADE"
    4355                elif self._match_text_seq("RESTRICT"):
    4356                    action = "RESTRICT"
    4357                elif self._match_pair(TokenType.SET, TokenType.NULL):
    4358                    action = "SET NULL"
    4359                elif self._match_pair(TokenType.SET, TokenType.DEFAULT):
    4360                    action = "SET DEFAULT"
    4361                else:
    4362                    self.raise_error("Invalid key constraint")
    4363
    4364                options.append(f"ON {on} {action}")
    4365            elif self._match_text_seq("NOT", "ENFORCED"):
    4366                options.append("NOT ENFORCED")
    4367            elif self._match_text_seq("DEFERRABLE"):
    4368                options.append("DEFERRABLE")
    4369            elif self._match_text_seq("INITIALLY", "DEFERRED"):
    4370                options.append("INITIALLY DEFERRED")
    4371            elif self._match_text_seq("NORELY"):
    4372                options.append("NORELY")
    4373            elif self._match_text_seq("MATCH", "FULL"):
    4374                options.append("MATCH FULL")
    4375            else:
    4376                break
    4377
    4378        return options
    4379
    4380    def _parse_references(self, match: bool = True) -> t.Optional[exp.Reference]:
    4381        if match and not self._match(TokenType.REFERENCES):
    4382            return None
    4383
    4384        expressions = None
    4385        this = self._parse_table(schema=True)
    4386        options = self._parse_key_constraint_options()
    4387        return self.expression(exp.Reference, this=this, expressions=expressions, options=options)
    4388
    4389    def _parse_foreign_key(self) -> exp.ForeignKey:
    4390        expressions = self._parse_wrapped_id_vars()
    4391        reference = self._parse_references()
    4392        options = {}
    4393
    4394        while self._match(TokenType.ON):
    4395            if not self._match_set((TokenType.DELETE, TokenType.UPDATE)):
    4396                self.raise_error("Expected DELETE or UPDATE")
    4397
    4398            kind = self._prev.text.lower()
    4399
    4400            if self._match_text_seq("NO", "ACTION"):
    4401                action = "NO ACTION"
    4402            elif self._match(TokenType.SET):
    4403                self._match_set((TokenType.NULL, TokenType.DEFAULT))
    4404                action = "SET " + self._prev.text.upper()
    4405            else:
    4406                self._advance()
    4407                action = self._prev.text.upper()
    4408
    4409            options[kind] = action
    4410
    4411        return self.expression(
    4412            exp.ForeignKey,
    4413            expressions=expressions,
    4414            reference=reference,
    4415            **options,  # type: ignore
    4416        )
    4417
    4418    def _parse_primary_key_part(self) -> t.Optional[exp.Expression]:
    4419        return self._parse_field()
    4420
    4421    def _parse_period_for_system_time(self) -> t.Optional[exp.PeriodForSystemTimeConstraint]:
    4422        if not self._match(TokenType.TIMESTAMP_SNAPSHOT):
    4423            self._retreat(self._index - 1)
    4424            return None
    4425
    4426        id_vars = self._parse_wrapped_id_vars()
    4427        return self.expression(
    4428            exp.PeriodForSystemTimeConstraint,
    4429            this=seq_get(id_vars, 0),
    4430            expression=seq_get(id_vars, 1),
    4431        )
    4432
    4433    def _parse_primary_key(
    4434        self, wrapped_optional: bool = False, in_props: bool = False
    4435    ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
    4436        desc = (
    4437            self._match_set((TokenType.ASC, TokenType.DESC))
    4438            and self._prev.token_type == TokenType.DESC
    4439        )
    4440
    4441        if not in_props and not self._match(TokenType.L_PAREN, advance=False):
    4442            return self.expression(exp.PrimaryKeyColumnConstraint, desc=desc)
    4443
    4444        expressions = self._parse_wrapped_csv(
    4445            self._parse_primary_key_part, optional=wrapped_optional
    4446        )
    4447        options = self._parse_key_constraint_options()
    4448        return self.expression(exp.PrimaryKey, expressions=expressions, options=options)
    4449
    4450    def _parse_bracket_key_value(self, is_map: bool = False) -> t.Optional[exp.Expression]:
    4451        return self._parse_slice(self._parse_alias(self._parse_conjunction(), explicit=True))
    4452
    4453    def _parse_bracket(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    4454        if not self._match_set((TokenType.L_BRACKET, TokenType.L_BRACE)):
    4455            return this
    4456
    4457        bracket_kind = self._prev.token_type
    4458        expressions = self._parse_csv(
    4459            lambda: self._parse_bracket_key_value(is_map=bracket_kind == TokenType.L_BRACE)
    4460        )
    4461
    4462        if not self._match(TokenType.R_BRACKET) and bracket_kind == TokenType.L_BRACKET:
    4463            self.raise_error("Expected ]")
    4464        elif not self._match(TokenType.R_BRACE) and bracket_kind == TokenType.L_BRACE:
    4465            self.raise_error("Expected }")
    4466
    4467        # https://duckdb.org/docs/sql/data_types/struct.html#creating-structs
    4468        if bracket_kind == TokenType.L_BRACE:
    4469            this = self.expression(exp.Struct, expressions=expressions)
    4470        elif not this or this.name.upper() == "ARRAY":
    4471            this = self.expression(exp.Array, expressions=expressions)
    4472        else:
    4473            expressions = apply_index_offset(this, expressions, -self.dialect.INDEX_OFFSET)
    4474            this = self.expression(exp.Bracket, this=this, expressions=expressions)
    4475
    4476        self._add_comments(this)
    4477        return self._parse_bracket(this)
    4478
    4479    def _parse_slice(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    4480        if self._match(TokenType.COLON):
    4481            return self.expression(exp.Slice, this=this, expression=self._parse_conjunction())
    4482        return this
    4483
    4484    def _parse_case(self) -> t.Optional[exp.Expression]:
    4485        ifs = []
    4486        default = None
    4487
    4488        comments = self._prev_comments
    4489        expression = self._parse_conjunction()
    4490
    4491        while self._match(TokenType.WHEN):
    4492            this = self._parse_conjunction()
    4493            self._match(TokenType.THEN)
    4494            then = self._parse_conjunction()
    4495            ifs.append(self.expression(exp.If, this=this, true=then))
    4496
    4497        if self._match(TokenType.ELSE):
    4498            default = self._parse_conjunction()
    4499
    4500        if not self._match(TokenType.END):
    4501            if isinstance(default, exp.Interval) and default.this.sql().upper() == "END":
    4502                default = exp.column("interval")
    4503            else:
    4504                self.raise_error("Expected END after CASE", self._prev)
    4505
    4506        return self._parse_window(
    4507            self.expression(exp.Case, comments=comments, this=expression, ifs=ifs, default=default)
    4508        )
    4509
    4510    def _parse_if(self) -> t.Optional[exp.Expression]:
    4511        if self._match(TokenType.L_PAREN):
    4512            args = self._parse_csv(self._parse_conjunction)
    4513            this = self.validate_expression(exp.If.from_arg_list(args), args)
    4514            self._match_r_paren()
    4515        else:
    4516            index = self._index - 1
    4517
    4518            if self.NO_PAREN_IF_COMMANDS and index == 0:
    4519                return self._parse_as_command(self._prev)
    4520
    4521            condition = self._parse_conjunction()
    4522
    4523            if not condition:
    4524                self._retreat(index)
    4525                return None
    4526
    4527            self._match(TokenType.THEN)
    4528            true = self._parse_conjunction()
    4529            false = self._parse_conjunction() if self._match(TokenType.ELSE) else None
    4530            self._match(TokenType.END)
    4531            this = self.expression(exp.If, this=condition, true=true, false=false)
    4532
    4533        return self._parse_window(this)
    4534
    4535    def _parse_next_value_for(self) -> t.Optional[exp.Expression]:
    4536        if not self._match_text_seq("VALUE", "FOR"):
    4537            self._retreat(self._index - 1)
    4538            return None
    4539
    4540        return self.expression(
    4541            exp.NextValueFor,
    4542            this=self._parse_column(),
    4543            order=self._match(TokenType.OVER) and self._parse_wrapped(self._parse_order),
    4544        )
    4545
    4546    def _parse_extract(self) -> exp.Extract:
    4547        this = self._parse_function() or self._parse_var() or self._parse_type()
    4548
    4549        if self._match(TokenType.FROM):
    4550            return self.expression(exp.Extract, this=this, expression=self._parse_bitwise())
    4551
    4552        if not self._match(TokenType.COMMA):
    4553            self.raise_error("Expected FROM or comma after EXTRACT", self._prev)
    4554
    4555        return self.expression(exp.Extract, this=this, expression=self._parse_bitwise())
    4556
    4557    def _parse_any_value(self) -> exp.AnyValue:
    4558        this = self._parse_lambda()
    4559        is_max = None
    4560        having = None
    4561
    4562        if self._match(TokenType.HAVING):
    4563            self._match_texts(("MAX", "MIN"))
    4564            is_max = self._prev.text == "MAX"
    4565            having = self._parse_column()
    4566
    4567        return self.expression(exp.AnyValue, this=this, having=having, max=is_max)
    4568
    4569    def _parse_cast(self, strict: bool, safe: t.Optional[bool] = None) -> exp.Expression:
    4570        this = self._parse_conjunction()
    4571
    4572        if not self._match(TokenType.ALIAS):
    4573            if self._match(TokenType.COMMA):
    4574                return self.expression(exp.CastToStrType, this=this, to=self._parse_string())
    4575
    4576            self.raise_error("Expected AS after CAST")
    4577
    4578        fmt = None
    4579        to = self._parse_types()
    4580
    4581        if self._match(TokenType.FORMAT):
    4582            fmt_string = self._parse_string()
    4583            fmt = self._parse_at_time_zone(fmt_string)
    4584
    4585            if not to:
    4586                to = exp.DataType.build(exp.DataType.Type.UNKNOWN)
    4587            if to.this in exp.DataType.TEMPORAL_TYPES:
    4588                this = self.expression(
    4589                    exp.StrToDate if to.this == exp.DataType.Type.DATE else exp.StrToTime,
    4590                    this=this,
    4591                    format=exp.Literal.string(
    4592                        format_time(
    4593                            fmt_string.this if fmt_string else "",
    4594                            self.dialect.FORMAT_MAPPING or self.dialect.TIME_MAPPING,
    4595                            self.dialect.FORMAT_TRIE or self.dialect.TIME_TRIE,
    4596                        )
    4597                    ),
    4598                )
    4599
    4600                if isinstance(fmt, exp.AtTimeZone) and isinstance(this, exp.StrToTime):
    4601                    this.set("zone", fmt.args["zone"])
    4602                return this
    4603        elif not to:
    4604            self.raise_error("Expected TYPE after CAST")
    4605        elif isinstance(to, exp.Identifier):
    4606            to = exp.DataType.build(to.name, udt=True)
    4607        elif to.this == exp.DataType.Type.CHAR:
    4608            if self._match(TokenType.CHARACTER_SET):
    4609                to = self.expression(exp.CharacterSet, this=self._parse_var_or_string())
    4610
    4611        return self.expression(
    4612            exp.Cast if strict else exp.TryCast, this=this, to=to, format=fmt, safe=safe
    4613        )
    4614
    4615    def _parse_string_agg(self) -> exp.Expression:
    4616        if self._match(TokenType.DISTINCT):
    4617            args: t.List[t.Optional[exp.Expression]] = [
    4618                self.expression(exp.Distinct, expressions=[self._parse_conjunction()])
    4619            ]
    4620            if self._match(TokenType.COMMA):
    4621                args.extend(self._parse_csv(self._parse_conjunction))
    4622        else:
    4623            args = self._parse_csv(self._parse_conjunction)  # type: ignore
    4624
    4625        index = self._index
    4626        if not self._match(TokenType.R_PAREN) and args:
    4627            # postgres: STRING_AGG([DISTINCT] expression, separator [ORDER BY expression1 {ASC | DESC} [, ...]])
    4628            # bigquery: STRING_AGG([DISTINCT] expression [, separator] [ORDER BY key [{ASC | DESC}] [, ... ]] [LIMIT n])
    4629            args[-1] = self._parse_limit(this=self._parse_order(this=args[-1]))
    4630            return self.expression(exp.GroupConcat, this=args[0], separator=seq_get(args, 1))
    4631
    4632        # Checks if we can parse an order clause: WITHIN GROUP (ORDER BY <order_by_expression_list> [ASC | DESC]).
    4633        # This is done "manually", instead of letting _parse_window parse it into an exp.WithinGroup node, so that
    4634        # the STRING_AGG call is parsed like in MySQL / SQLite and can thus be transpiled more easily to them.
    4635        if not self._match_text_seq("WITHIN", "GROUP"):
    4636            self._retreat(index)
    4637            return self.validate_expression(exp.GroupConcat.from_arg_list(args), args)
    4638
    4639        self._match_l_paren()  # The corresponding match_r_paren will be called in parse_function (caller)
    4640        order = self._parse_order(this=seq_get(args, 0))
    4641        return self.expression(exp.GroupConcat, this=order, separator=seq_get(args, 1))
    4642
    4643    def _parse_convert(
    4644        self, strict: bool, safe: t.Optional[bool] = None
    4645    ) -> t.Optional[exp.Expression]:
    4646        this = self._parse_bitwise()
    4647
    4648        if self._match(TokenType.USING):
    4649            to: t.Optional[exp.Expression] = self.expression(
    4650                exp.CharacterSet, this=self._parse_var()
    4651            )
    4652        elif self._match(TokenType.COMMA):
    4653            to = self._parse_types()
    4654        else:
    4655            to = None
    4656
    4657        return self.expression(exp.Cast if strict else exp.TryCast, this=this, to=to, safe=safe)
    4658
    4659    def _parse_decode(self) -> t.Optional[exp.Decode | exp.Case]:
    4660        """
    4661        There are generally two variants of the DECODE function:
    4662
    4663        - DECODE(bin, charset)
    4664        - DECODE(expression, search, result [, search, result] ... [, default])
    4665
    4666        The second variant will always be parsed into a CASE expression. Note that NULL
    4667        needs special treatment, since we need to explicitly check for it with `IS NULL`,
    4668        instead of relying on pattern matching.
    4669        """
    4670        args = self._parse_csv(self._parse_conjunction)
    4671
    4672        if len(args) < 3:
    4673            return self.expression(exp.Decode, this=seq_get(args, 0), charset=seq_get(args, 1))
    4674
    4675        expression, *expressions = args
    4676        if not expression:
    4677            return None
    4678
    4679        ifs = []
    4680        for search, result in zip(expressions[::2], expressions[1::2]):
    4681            if not search or not result:
    4682                return None
    4683
    4684            if isinstance(search, exp.Literal):
    4685                ifs.append(
    4686                    exp.If(this=exp.EQ(this=expression.copy(), expression=search), true=result)
    4687                )
    4688            elif isinstance(search, exp.Null):
    4689                ifs.append(
    4690                    exp.If(this=exp.Is(this=expression.copy(), expression=exp.Null()), true=result)
    4691                )
    4692            else:
    4693                cond = exp.or_(
    4694                    exp.EQ(this=expression.copy(), expression=search),
    4695                    exp.and_(
    4696                        exp.Is(this=expression.copy(), expression=exp.Null()),
    4697                        exp.Is(this=search.copy(), expression=exp.Null()),
    4698                        copy=False,
    4699                    ),
    4700                    copy=False,
    4701                )
    4702                ifs.append(exp.If(this=cond, true=result))
    4703
    4704        return exp.Case(ifs=ifs, default=expressions[-1] if len(expressions) % 2 == 1 else None)
    4705
    4706    def _parse_json_key_value(self) -> t.Optional[exp.JSONKeyValue]:
    4707        self._match_text_seq("KEY")
    4708        key = self._parse_column()
    4709        self._match_set(self.JSON_KEY_VALUE_SEPARATOR_TOKENS)
    4710        self._match_text_seq("VALUE")
    4711        value = self._parse_bitwise()
    4712
    4713        if not key and not value:
    4714            return None
    4715        return self.expression(exp.JSONKeyValue, this=key, expression=value)
    4716
    4717    def _parse_format_json(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
    4718        if not this or not self._match_text_seq("FORMAT", "JSON"):
    4719            return this
    4720
    4721        return self.expression(exp.FormatJson, this=this)
    4722
    4723    def _parse_on_handling(self, on: str, *values: str) -> t.Optional[str]:
    4724        # Parses the "X ON Y" syntax, i.e. NULL ON NULL (Oracle, T-SQL)
    4725        for value in values:
    4726            if self._match_text_seq(value, "ON", on):
    4727                return f"{value} ON {on}"
    4728
    4729        return None
    4730
    4731    @t.overload
    4732    def _parse_json_object(self, agg: Lit[False]) -> exp.JSONObject:
    4733        ...
    4734
    4735    @t.overload
    4736    def _parse_json_object(self, agg: Lit[True]) -> exp.JSONObjectAgg:
    4737        ...
    4738
    4739    def _parse_json_object(self, agg=False):
    4740        star = self._parse_star()
    4741        expressions = (
    4742            [star]
    4743            if star
    4744            else self._parse_csv(lambda: self._parse_format_json(self._parse_json_key_value()))
    4745        )
    4746        null_handling = self._parse_on_handling("NULL", "NULL", "ABSENT")
    4747
    4748        unique_keys = None
    4749        if self._match_text_seq("WITH", "UNIQUE"):
    4750            unique_keys = True
    4751        elif self._match_text_seq("WITHOUT", "UNIQUE"):
    4752            unique_keys = False
    4753
    4754        self._match_text_seq("KEYS")
    4755
    4756        return_type = self._match_text_seq("RETURNING") and self._parse_format_json(
    4757            self._parse_type()
    4758        )
    4759        encoding = self._match_text_seq("ENCODING") and self._parse_var()
    4760
    4761        return self.expression(
    4762            exp.JSONObjectAgg if agg else exp.JSONObject,
    4763            expressions=expressions,
    4764            null_handling=null_handling,
    4765            unique_keys=unique_keys,
    4766            return_type=return_type,
    4767            encoding=encoding,
    4768        )
    4769
    4770    # Note: this is currently incomplete; it only implements the "JSON_value_column" part
    4771    def _parse_json_column_def(self) -> exp.JSONColumnDef:
    4772        if not self._match_text_seq("NESTED"):
    4773            this = self._parse_id_var()
    4774            kind = self._parse_types(allow_identifiers=False)
    4775            nested = None
    4776        else:
    4777            this = None
    4778            kind = None
    4779            nested = True
    4780
    4781        path = self._match_text_seq("PATH") and self._parse_string()
    4782        nested_schema = nested and self._parse_json_schema()
    4783
    4784        return self.expression(
    4785            exp.JSONColumnDef,
    4786            this=this,
    4787            kind=kind,
    4788            path=path,
    4789            nested_schema=nested_schema,
    4790        )
    4791
    4792    def _parse_json_schema(self) -> exp.JSONSchema:
    4793        self._match_text_seq("COLUMNS")
    4794        return self.expression(
    4795            exp.JSONSchema,
    4796            expressions=self._parse_wrapped_csv(self._parse_json_column_def, optional=True),
    4797        )
    4798
    4799    def _parse_json_table(self) -> exp.JSONTable:
    4800        this = self._parse_format_json(self._parse_bitwise())
    4801        path = self._match(TokenType.COMMA) and self._parse_string()
    4802        error_handling = self._parse_on_handling("ERROR", "ERROR", "NULL")
    4803        empty_handling = self._parse_on_handling("EMPTY", "ERROR", "NULL")
    4804        schema = self._parse_json_schema()
    4805
    4806        return exp.JSONTable(
    4807            this=this,
    4808            schema=schema,
    4809            path=path,
    4810            error_handling=error_handling,
    4811            empty_handling=empty_handling,
    4812        )
    4813
    4814    def _parse_match_against(self) -> exp.MatchAgainst:
    4815        expressions = self._parse_csv(self._parse_column)
    4816
    4817        self._match_text_seq(")", "AGAINST", "(")
    4818
    4819        this = self._parse_string()
    4820
    4821        if self._match_text_seq("IN", "NATURAL", "LANGUAGE", "MODE"):
    4822            modifier = "IN NATURAL LANGUAGE MODE"
    4823            if self._match_text_seq("WITH", "QUERY", "EXPANSION"):
    4824                modifier = f"{modifier} WITH QUERY EXPANSION"
    4825        elif self._match_text_seq("IN", "BOOLEAN", "MODE"):
    4826            modifier = "IN BOOLEAN MODE"
    4827        elif self._match_text_seq("WITH", "QUERY", "EXPANSION"):
    4828            modifier = "WITH QUERY EXPANSION"
    4829        else:
    4830            modifier = None
    4831
    4832        return self.expression(
    4833            exp.MatchAgainst, this=this, expressions=expressions, modifier=modifier
    4834        )
    4835
    4836    # https://learn.microsoft.com/en-us/sql/t-sql/functions/openjson-transact-sql?view=sql-server-ver16
    4837    def _parse_open_json(self) -> exp.OpenJSON:
    4838        this = self._parse_bitwise()
    4839        path = self._match(TokenType.COMMA) and self._parse_string()
    4840
    4841        def _parse_open_json_column_def() -> exp.OpenJSONColumnDef:
    4842            this = self._parse_field(any_token=True)
    4843            kind = self._parse_types()
    4844            path = self._parse_string()
    4845            as_json = self._match_pair(TokenType.ALIAS, TokenType.JSON)
    4846
    4847            return self.expression(
    4848                exp.OpenJSONColumnDef, this=this, kind=kind, path=path, as_json=as_json
    4849            )
    4850
    4851        expressions = None
    4852        if self._match_pair(TokenType.R_PAREN, TokenType.WITH):
    4853            self._match_l_paren()
    4854            expressions = self._parse_csv(_parse_open_json_column_def)
    4855
    4856        return self.expression(exp.OpenJSON, this=this, path=path, expressions=expressions)
    4857
    4858    def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
    4859        args = self._parse_csv(self._parse_bitwise)
    4860
    4861        if self._match(TokenType.IN):
    4862            return self.expression(
    4863                exp.StrPosition, this=self._parse_bitwise(), substr=seq_get(args, 0)
    4864            )
    4865
    4866        if haystack_first:
    4867            haystack = seq_get(args, 0)
    4868            needle = seq_get(args, 1)
    4869        else:
    4870            needle = seq_get(args, 0)
    4871            haystack = seq_get(args, 1)
    4872
    4873        return self.expression(
    4874            exp.StrPosition, this=haystack, substr=needle, position=seq_get(args, 2)
    4875        )
    4876
    4877    def _parse_predict(self) -> exp.Predict:
    4878        self._match_text_seq("MODEL")
    4879        this = self._parse_table()
    4880
    4881        self._match(TokenType.COMMA)
    4882        self._match_text_seq("TABLE")
    4883
    4884        return self.expression(
    4885            exp.Predict,
    4886            this=this,
    4887            expression=self._parse_table(),
    4888            params_struct=self._match(TokenType.COMMA) and self._parse_bitwise(),
    4889        )
    4890
    4891    def _parse_join_hint(self, func_name: str) -> exp.JoinHint:
    4892        args = self._parse_csv(self._parse_table)
    4893        return exp.JoinHint(this=func_name.upper(), expressions=args)
    4894
    4895    def _parse_substring(self) -> exp.Substring:
    4896        # Postgres supports the form: substring(string [from int] [for int])
    4897        # https://www.postgresql.org/docs/9.1/functions-string.html @ Table 9-6
    4898
    4899        args = t.cast(t.List[t.Optional[exp.Expression]], self._parse_csv(self._parse_bitwise))
    4900
    4901        if self._match(TokenType.FROM):
    4902            args.append(self._parse_bitwise())
    4903            if self._match(TokenType.FOR):
    4904                args.append(self._parse_bitwise())
    4905
    4906        return self.validate_expression(exp.Substring.from_arg_list(args), args)
    4907
    4908    def _parse_trim(self) -> exp.Trim:
    4909        # https://www.w3resource.com/sql/character-functions/trim.php
    4910        # https://docs.oracle.com/javadb/10.8.3.0/ref/rreftrimfunc.html
    4911
    4912        position = None
    4913        collation = None
    4914        expression = None
    4915
    4916        if self._match_texts(self.TRIM_TYPES):
    4917            position = self._prev.text.upper()
    4918
    4919        this = self._parse_bitwise()
    4920        if self._match_set((TokenType.FROM, TokenType.COMMA)):
    4921            invert_order = self._prev.token_type == TokenType.FROM or self.TRIM_PATTERN_FIRST
    4922            expression = self._parse_bitwise()
    4923
    4924            if invert_order:
    4925                this, expression = expression, this
    4926
    4927        if self._match(TokenType.COLLATE):
    4928            collation = self._parse_bitwise()
    4929
    4930        return self.expression(
    4931            exp.Trim, this=this, position=position, expression=expression, collation=collation
    4932        )
    4933
    4934    def _parse_window_clause(self) -> t.Optional[t.List[exp.Expression]]:
    4935        return self._match(TokenType.WINDOW) and self._parse_csv(self._parse_named_window)
    4936
    4937    def _parse_named_window(self) -> t.Optional[exp.Expression]:
    4938        return self._parse_window(self._parse_id_var(), alias=True)
    4939
    4940    def _parse_respect_or_ignore_nulls(
    4941        self, this: t.Optional[exp.Expression]
    4942    ) -> t.Optional[exp.Expression]:
    4943        if self._match_text_seq("IGNORE", "NULLS"):
    4944            return self.expression(exp.IgnoreNulls, this=this)
    4945        if self._match_text_seq("RESPECT", "NULLS"):
    4946            return self.expression(exp.RespectNulls, this=this)
    4947        return this
    4948
    4949    def _parse_window(
    4950        self, this: t.Optional[exp.Expression], alias: bool = False
    4951    ) -> t.Optional[exp.Expression]:
    4952        if self._match_pair(TokenType.FILTER, TokenType.L_PAREN):
    4953            self._match(TokenType.WHERE)
    4954            this = self.expression(
    4955                exp.Filter, this=this, expression=self._parse_where(skip_where_token=True)
    4956            )
    4957            self._match_r_paren()
    4958
    4959        # T-SQL allows the OVER (...) syntax after WITHIN GROUP.
    4960        # https://learn.microsoft.com/en-us/sql/t-sql/functions/percentile-disc-transact-sql?view=sql-server-ver16
    4961        if self._match_text_seq("WITHIN", "GROUP"):
    4962            order = self._parse_wrapped(self._parse_order)
    4963            this = self.expression(exp.WithinGroup, this=this, expression=order)
    4964
    4965        # SQL spec defines an optional [ { IGNORE | RESPECT } NULLS ] OVER
    4966        # Some dialects choose to implement and some do not.
    4967        # https://dev.mysql.com/doc/refman/8.0/en/window-function-descriptions.html
    4968
    4969        # There is some code above in _parse_lambda that handles
    4970        #   SELECT FIRST_VALUE(TABLE.COLUMN IGNORE|RESPECT NULLS) OVER ...
    4971
    4972        # The below changes handle
    4973        #   SELECT FIRST_VALUE(TABLE.COLUMN) IGNORE|RESPECT NULLS OVER ...
    4974
    4975        # Oracle allows both formats
    4976        #   (https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/img_text/first_value.html)
    4977        #   and Snowflake chose to do the same for familiarity
    4978        #   https://docs.snowflake.com/en/sql-reference/functions/first_value.html#usage-notes
    4979        if isinstance(this, exp.AggFunc):
    4980            ignore_respect = this.find(exp.IgnoreNulls, exp.RespectNulls)
    4981
    4982            if ignore_respect and ignore_respect is not this:
    4983                ignore_respect.replace(ignore_respect.this)
    4984                this = self.expression(ignore_respect.__class__, this=this)
    4985
    4986        this = self._parse_respect_or_ignore_nulls(this)
    4987
    4988        # bigquery select from window x AS (partition by ...)
    4989        if alias:
    4990            over = None
    4991            self._match(TokenType.ALIAS)
    4992        elif not self._match_set(self.WINDOW_BEFORE_PAREN_TOKENS):
    4993            return this
    4994        else:
    4995            over = self._prev.text.upper()
    4996
    4997        if not self._match(TokenType.L_PAREN):
    4998            return self.expression(
    4999                exp.Window, this=this, alias=self._parse_id_var(False), over=over
    5000            )
    5001
    5002        window_alias = self._parse_id_var(any_token=False, tokens=self.WINDOW_ALIAS_TOKENS)
    5003
    5004        first = self._match(TokenType.FIRST)
    5005        if self._match_text_seq("LAST"):
    5006            first = False
    5007
    5008        partition, order = self._parse_partition_and_order()
    5009        kind = self._match_set((TokenType.ROWS, TokenType.RANGE)) and self._prev.text
    5010
    5011        if kind:
    5012            self._match(TokenType.BETWEEN)
    5013            start = self._parse_window_spec()
    5014            self._match(TokenType.AND)
    5015            end = self._parse_window_spec()
    5016
    5017            spec = self.expression(
    5018                exp.WindowSpec,
    5019                kind=kind,
    5020                start=start["value"],
    5021                start_side=start["side"],
    5022                end=end["value"],
    5023                end_side=end["side"],
    5024            )
    5025        else:
    5026            spec = None
    5027
    5028        self._match_r_paren()
    5029
    5030        window = self.expression(
    5031            exp.Window,
    5032            this=this,
    5033            partition_by=partition,
    5034            order=order,
    5035            spec=spec,
    5036            alias=window_alias,
    5037            over=over,
    5038            first=first,
    5039        )
    5040
    5041        # This covers Oracle's FIRST/LAST syntax: aggregate KEEP (...) OVER (...)
    5042        if self._match_set(self.WINDOW_BEFORE_PAREN_TOKENS, advance=False):
    5043            return self._parse_window(window, alias=alias)
    5044
    5045        return window
    5046
    5047    def _parse_partition_and_order(
    5048        self,
    5049    ) -> t.Tuple[t.List[exp.Expression], t.Optional[exp.Expression]]:
    5050        return self._parse_partition_by(), self._parse_order()
    5051
    5052    def _parse_window_spec(self) -> t.Dict[str, t.Optional[str | exp.Expression]]:
    5053        self._match(TokenType.BETWEEN)
    5054
    5055        return {
    5056            "value": (
    5057                (self._match_text_seq("UNBOUNDED") and "UNBOUNDED")
    5058                or (self._match_text_seq("CURRENT", "ROW") and "CURRENT ROW")
    5059                or self._parse_bitwise()
    5060            ),
    5061            "side": self._match_texts(self.WINDOW_SIDES) and self._prev.text,
    5062        }
    5063
    5064    def _parse_alias(
    5065        self, this: t.Optional[exp.Expression], explicit: bool = False
    5066    ) -> t.Optional[exp.Expression]:
    5067        any_token = self._match(TokenType.ALIAS)
    5068        comments = self._prev_comments
    5069
    5070        if explicit and not any_token:
    5071            return this
    5072
    5073        if self._match(TokenType.L_PAREN):
    5074            aliases = self.expression(
    5075                exp.Aliases,
    5076                comments=comments,
    5077                this=this,
    5078                expressions=self._parse_csv(lambda: self._parse_id_var(any_token)),
    5079            )
    5080            self._match_r_paren(aliases)
    5081            return aliases
    5082
    5083        alias = self._parse_id_var(any_token) or (
    5084            self.STRING_ALIASES and self._parse_string_as_identifier()
    5085        )
    5086
    5087        if alias:
    5088            this = self.expression(exp.Alias, comments=comments, this=this, alias=alias)
    5089            column = this.this
    5090
    5091            # Moves the comment next to the alias in `expr /* comment */ AS alias`
    5092            if not this.comments and column and column.comments:
    5093                this.comments = column.comments
    5094                column.comments = None
    5095
    5096        return this
    5097
    5098    def _parse_id_var(
    5099        self,
    5100        any_token: bool = True,
    5101        tokens: t.Optional[t.Collection[TokenType]] = None,
    5102    ) -> t.Optional[exp.Expression]:
    5103        identifier = self._parse_identifier()
    5104
    5105        if identifier:
    5106            return identifier
    5107
    5108        if (any_token and self._advance_any()) or self._match_set(tokens or self.ID_VAR_TOKENS):
    5109            quoted = self._prev.token_type == TokenType.STRING
    5110            return exp.Identifier(this=self._prev.text, quoted=quoted)
    5111
    5112        return None
    5113
    5114    def _parse_string(self) -> t.Optional[exp.Expression]:
    5115        if self._match_set((TokenType.STRING, TokenType.RAW_STRING)):
    5116            return self.PRIMARY_PARSERS[self._prev.token_type](self, self._prev)
    5117        return self._parse_placeholder()
    5118
    5119    def _parse_string_as_identifier(self) -> t.Optional[exp.Identifier]:
    5120        return exp.to_identifier(self._match(TokenType.STRING) and self._prev.text, quoted=True)
    5121
    5122    def _parse_number(self) -> t.Optional[exp.Expression]:
    5123        if self._match(TokenType.NUMBER):
    5124            return self.PRIMARY_PARSERS[TokenType.NUMBER](self, self._prev)
    5125        return self._parse_placeholder()
    5126
    5127    def _parse_identifier(self) -> t.Optional[exp.Expression]:
    5128        if self._match(TokenType.IDENTIFIER):
    5129            return self.expression(exp.Identifier, this=self._prev.text, quoted=True)
    5130        return self._parse_placeholder()
    5131
    5132    def _parse_var(
    5133        self,
    5134        any_token: bool = False,
    5135        tokens: t.Optional[t.Collection[TokenType]] = None,
    5136        upper: bool = False,
    5137    ) -> t.Optional[exp.Expression]:
    5138        if (
    5139            (any_token and self._advance_any())
    5140            or self._match(TokenType.VAR)
    5141            or (self._match_set(tokens) if tokens else False)
    5142        ):
    5143            return self.expression(
    5144                exp.Var, this=self._prev.text.upper() if upper else self._prev.text
    5145            )
    5146        return self._parse_placeholder()
    5147
    5148    def _advance_any(self, ignore_reserved: bool = False) -> t.Optional[Token]:
    5149        if self._curr and (ignore_reserved or self._curr.token_type not in self.RESERVED_TOKENS):
    5150            self._advance()
    5151            return self._prev
    5152        return None
    5153
    5154    def _parse_var_or_string(self) -> t.Optional[exp.Expression]:
    5155        return self._parse_var() or self._parse_string()
    5156
    5157    def _parse_null(self) -> t.Optional[exp.Expression]:
    5158        if self._match_set(self.NULL_TOKENS):
    5159            return self.PRIMARY_PARSERS[TokenType.NULL](self, self._prev)
    5160        return self._parse_placeholder()
    5161
    5162    def _parse_boolean(self) -> t.Optional[exp.Expression]:
    5163        if self._match(TokenType.TRUE):
    5164            return self.PRIMARY_PARSERS[TokenType.TRUE](self, self._prev)
    5165        if self._match(TokenType.FALSE):
    5166            return self.PRIMARY_PARSERS[TokenType.FALSE](self, self._prev)
    5167        return self._parse_placeholder()
    5168
    5169    def _parse_star(self) -> t.Optional[exp.Expression]:
    5170        if self._match(TokenType.STAR):
    5171            return self.PRIMARY_PARSERS[TokenType.STAR](self, self._prev)
    5172        return self._parse_placeholder()
    5173
    5174    def _parse_parameter(self) -> exp.Parameter:
    5175        def _parse_parameter_part() -> t.Optional[exp.Expression]:
    5176            return (
    5177                self._parse_identifier() or self._parse_primary() or self._parse_var(any_token=True)
    5178            )
    5179
    5180        self._match(TokenType.L_BRACE)
    5181        this = _parse_parameter_part()
    5182        expression = self._match(TokenType.COLON) and _parse_parameter_part()
    5183        self._match(TokenType.R_BRACE)
    5184
    5185        return self.expression(exp.Parameter, this=this, expression=expression)
    5186
    5187    def _parse_placeholder(self) -> t.Optional[exp.Expression]:
    5188        if self._match_set(self.PLACEHOLDER_PARSERS):
    5189            placeholder = self.PLACEHOLDER_PARSERS[self._prev.token_type](self)
    5190            if placeholder:
    5191                return placeholder
    5192            self._advance(-1)
    5193        return None
    5194
    5195    def _parse_except(self) -> t.Optional[t.List[exp.Expression]]:
    5196        if not self._match(TokenType.EXCEPT):
    5197            return None
    5198        if self._match(TokenType.L_PAREN, advance=False):
    5199            return self._parse_wrapped_csv(self._parse_column)
    5200
    5201        except_column = self._parse_column()
    5202        return [except_column] if except_column else None
    5203
    5204    def _parse_replace(self) -> t.Optional[t.List[exp.Expression]]:
    5205        if not self._match(TokenType.REPLACE):
    5206            return None
    5207        if self._match(TokenType.L_PAREN, advance=False):
    5208            return self._parse_wrapped_csv(self._parse_expression)
    5209
    5210        replace_expression = self._parse_expression()
    5211        return [replace_expression] if replace_expression else None
    5212
    5213    def _parse_csv(
    5214        self, parse_method: t.Callable, sep: TokenType = TokenType.COMMA
    5215    ) -> t.List[exp.Expression]:
    5216        parse_result = parse_method()
    5217        items = [parse_result] if parse_result is not None else []
    5218
    5219        while self._match(sep):
    5220            self._add_comments(parse_result)
    5221            parse_result = parse_method()
    5222            if parse_result is not None:
    5223                items.append(parse_result)
    5224
    5225        return items
    5226
    5227    def _parse_tokens(
    5228        self, parse_method: t.Callable, expressions: t.Dict
    5229    ) -> t.Optional[exp.Expression]:
    5230        this = parse_method()
    5231
    5232        while self._match_set(expressions):
    5233            this = self.expression(
    5234                expressions[self._prev.token_type],
    5235                this=this,
    5236                comments=self._prev_comments,
    5237                expression=parse_method(),
    5238            )
    5239
    5240        return this
    5241
    5242    def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
    5243        return self._parse_wrapped_csv(self._parse_id_var, optional=optional)
    5244
    5245    def _parse_wrapped_csv(
    5246        self, parse_method: t.Callable, sep: TokenType = TokenType.COMMA, optional: bool = False
    5247    ) -> t.List[exp.Expression]:
    5248        return self._parse_wrapped(
    5249            lambda: self._parse_csv(parse_method, sep=sep), optional=optional
    5250        )
    5251
    5252    def _parse_wrapped(self, parse_method: t.Callable, optional: bool = False) -> t.Any:
    5253        wrapped = self._match(TokenType.L_PAREN)
    5254        if not wrapped and not optional:
    5255            self.raise_error("Expecting (")
    5256        parse_result = parse_method()
    5257        if wrapped:
    5258            self._match_r_paren()
    5259        return parse_result
    5260
    5261    def _parse_expressions(self) -> t.List[exp.Expression]:
    5262        return self._parse_csv(self._parse_expression)
    5263
    5264    def _parse_select_or_expression(self, alias: bool = False) -> t.Optional[exp.Expression]:
    5265        return self._parse_select() or self._parse_set_operations(
    5266            self._parse_expression() if alias else self._parse_conjunction()
    5267        )
    5268
    5269    def _parse_ddl_select(self) -> t.Optional[exp.Expression]:
    5270        return self._parse_query_modifiers(
    5271            self._parse_set_operations(self._parse_select(nested=True, parse_subquery_alias=False))
    5272        )
    5273
    5274    def _parse_transaction(self) -> exp.Transaction | exp.Command:
    5275        this = None
    5276        if self._match_texts(self.TRANSACTION_KIND):
    5277            this = self._prev.text
    5278
    5279        self._match_texts(("TRANSACTION", "WORK"))
    5280
    5281        modes = []
    5282        while True:
    5283            mode = []
    5284            while self._match(TokenType.VAR):
    5285                mode.append(self._prev.text)
    5286
    5287            if mode:
    5288                modes.append(" ".join(mode))
    5289            if not self._match(TokenType.COMMA):
    5290                break
    5291
    5292        return self.expression(exp.Transaction, this=this, modes=modes)
    5293
    5294    def _parse_commit_or_rollback(self) -> exp.Commit | exp.Rollback:
    5295        chain = None
    5296        savepoint = None
    5297        is_rollback = self._prev.token_type == TokenType.ROLLBACK
    5298
    5299        self._match_texts(("TRANSACTION", "WORK"))
    5300
    5301        if self._match_text_seq("TO"):
    5302            self._match_text_seq("SAVEPOINT")
    5303            savepoint = self._parse_id_var()
    5304
    5305        if self._match(TokenType.AND):
    5306            chain = not self._match_text_seq("NO")
    5307            self._match_text_seq("CHAIN")
    5308
    5309        if is_rollback:
    5310            return self.expression(exp.Rollback, savepoint=savepoint)
    5311
    5312        return self.expression(exp.Commit, chain=chain)
    5313
    5314    def _parse_refresh(self) -> exp.Refresh:
    5315        self._match(TokenType.TABLE)
    5316        return self.expression(exp.Refresh, this=self._parse_string() or self._parse_table())
    5317
    5318    def _parse_add_column(self) -> t.Optional[exp.Expression]:
    5319        if not self._match_text_seq("ADD"):
    5320            return None
    5321
    5322        self._match(TokenType.COLUMN)
    5323        exists_column = self._parse_exists(not_=True)
    5324        expression = self._parse_field_def()
    5325
    5326        if expression:
    5327            expression.set("exists", exists_column)
    5328
    5329            # https://docs.databricks.com/delta/update-schema.html#explicitly-update-schema-to-add-columns
    5330            if self._match_texts(("FIRST", "AFTER")):
    5331                position = self._prev.text
    5332                column_position = self.expression(
    5333                    exp.ColumnPosition, this=self._parse_column(), position=position
    5334                )
    5335                expression.set("position", column_position)
    5336
    5337        return expression
    5338
    5339    def _parse_drop_column(self) -> t.Optional[exp.Drop | exp.Command]:
    5340        drop = self._match(TokenType.DROP) and self._parse_drop()
    5341        if drop and not isinstance(drop, exp.Command):
    5342            drop.set("kind", drop.args.get("kind", "COLUMN"))
    5343        return drop
    5344
    5345    # https://docs.aws.amazon.com/athena/latest/ug/alter-table-drop-partition.html
    5346    def _parse_drop_partition(self, exists: t.Optional[bool] = None) -> exp.DropPartition:
    5347        return self.expression(
    5348            exp.DropPartition, expressions=self._parse_csv(self._parse_partition), exists=exists
    5349        )
    5350
    5351    def _parse_add_constraint(self) -> exp.AddConstraint:
    5352        this = None
    5353        kind = self._prev.token_type
    5354
    5355        if kind == TokenType.CONSTRAINT:
    5356            this = self._parse_id_var()
    5357
    5358            if self._match_text_seq("CHECK"):
    5359                expression = self._parse_wrapped(self._parse_conjunction)
    5360                enforced = self._match_text_seq("ENFORCED") or False
    5361
    5362                return self.expression(
    5363                    exp.AddConstraint, this=this, expression=expression, enforced=enforced
    5364                )
    5365
    5366        if kind == TokenType.FOREIGN_KEY or self._match(TokenType.FOREIGN_KEY):
    5367            expression = self._parse_foreign_key()
    5368        elif kind == TokenType.PRIMARY_KEY or self._match(TokenType.PRIMARY_KEY):
    5369            expression = self._parse_primary_key()
    5370        else:
    5371            expression = None
    5372
    5373        return self.expression(exp.AddConstraint, this=this, expression=expression)
    5374
    5375    def _parse_alter_table_add(self) -> t.List[exp.Expression]:
    5376        index = self._index - 1
    5377
    5378        if self._match_set(self.ADD_CONSTRAINT_TOKENS):
    5379            return self._parse_csv(self._parse_add_constraint)
    5380
    5381        self._retreat(index)
    5382        if not self.ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN and self._match_text_seq("ADD"):
    5383            return self._parse_wrapped_csv(self._parse_field_def, optional=True)
    5384        return self._parse_wrapped_csv(self._parse_add_column, optional=True)
    5385
    5386    def _parse_alter_table_alter(self) -> exp.AlterColumn:
    5387        self._match(TokenType.COLUMN)
    5388        column = self._parse_field(any_token=True)
    5389
    5390        if self._match_pair(TokenType.DROP, TokenType.DEFAULT):
    5391            return self.expression(exp.AlterColumn, this=column, drop=True)
    5392        if self._match_pair(TokenType.SET, TokenType.DEFAULT):
    5393            return self.expression(exp.AlterColumn, this=column, default=self._parse_conjunction())
    5394        if self._match(TokenType.COMMENT):
    5395            return self.expression(exp.AlterColumn, this=column, comment=self._parse_string())
    5396
    5397        self._match_text_seq("SET", "DATA")
    5398        return self.expression(
    5399            exp.AlterColumn,
    5400            this=column,
    5401            dtype=self._match_text_seq("TYPE") and self._parse_types(),
    5402            collate=self._match(TokenType.COLLATE) and self._parse_term(),
    5403            using=self._match(TokenType.USING) and self._parse_conjunction(),
    5404        )
    5405
    5406    def _parse_alter_table_drop(self) -> t.List[exp.Expression]:
    5407        index = self._index - 1
    5408
    5409        partition_exists = self._parse_exists()
    5410        if self._match(TokenType.PARTITION, advance=False):
    5411            return self._parse_csv(lambda: self._parse_drop_partition(exists=partition_exists))
    5412
    5413        self._retreat(index)
    5414        return self._parse_csv(self._parse_drop_column)
    5415
    5416    def _parse_alter_table_rename(self) -> t.Optional[exp.RenameTable | exp.RenameColumn]:
    5417        if self._match(TokenType.COLUMN):
    5418            exists = self._parse_exists()
    5419            old_column = self._parse_column()
    5420            to = self._match_text_seq("TO")
    5421            new_column = self._parse_column()
    5422
    5423            if old_column is None or to is None or new_column is None:
    5424                return None
    5425
    5426            return self.expression(exp.RenameColumn, this=old_column, to=new_column, exists=exists)
    5427
    5428        self._match_text_seq("TO")
    5429        return self.expression(exp.RenameTable, this=self._parse_table(schema=True))
    5430
    5431    def _parse_alter(self) -> exp.AlterTable | exp.Command:
    5432        start = self._prev
    5433
    5434        if not self._match(TokenType.TABLE):
    5435            return self._parse_as_command(start)
    5436
    5437        exists = self._parse_exists()
    5438        only = self._match_text_seq("ONLY")
    5439        this = self._parse_table(schema=True)
    5440
    5441        if self._next:
    5442            self._advance()
    5443
    5444        parser = self.ALTER_PARSERS.get(self._prev.text.upper()) if self._prev else None
    5445        if parser:
    5446            actions = ensure_list(parser(self))
    5447
    5448            if not self._curr and actions:
    5449                return self.expression(
    5450                    exp.AlterTable,
    5451                    this=this,
    5452                    exists=exists,
    5453                    actions=actions,
    5454                    only=only,
    5455                )
    5456
    5457        return self._parse_as_command(start)
    5458
    5459    def _parse_merge(self) -> exp.Merge:
    5460        self._match(TokenType.INTO)
    5461        target = self._parse_table()
    5462
    5463        if target and self._match(TokenType.ALIAS, advance=False):
    5464            target.set("alias", self._parse_table_alias())
    5465
    5466        self._match(TokenType.USING)
    5467        using = self._parse_table()
    5468
    5469        self._match(TokenType.ON)
    5470        on = self._parse_conjunction()
    5471
    5472        return self.expression(
    5473            exp.Merge,
    5474            this=target,
    5475            using=using,
    5476            on=on,
    5477            expressions=self._parse_when_matched(),
    5478        )
    5479
    5480    def _parse_when_matched(self) -> t.List[exp.When]:
    5481        whens = []
    5482
    5483        while self._match(TokenType.WHEN):
    5484            matched = not self._match(TokenType.NOT)
    5485            self._match_text_seq("MATCHED")
    5486            source = (
    5487                False
    5488                if self._match_text_seq("BY", "TARGET")
    5489                else self._match_text_seq("BY", "SOURCE")
    5490            )
    5491            condition = self._parse_conjunction() if self._match(TokenType.AND) else None
    5492
    5493            self._match(TokenType.THEN)
    5494
    5495            if self._match(TokenType.INSERT):
    5496                _this = self._parse_star()
    5497                if _this:
    5498                    then: t.Optional[exp.Expression] = self.expression(exp.Insert, this=_this)
    5499                else:
    5500                    then = self.expression(
    5501                        exp.Insert,
    5502                        this=self._parse_value(),
    5503                        expression=self._match(TokenType.VALUES) and self._parse_value(),
    5504                    )
    5505            elif self._match(TokenType.UPDATE):
    5506                expressions = self._parse_star()
    5507                if expressions:
    5508                    then = self.expression(exp.Update, expressions=expressions)
    5509                else:
    5510                    then = self.expression(
    5511                        exp.Update,
    5512                        expressions=self._match(TokenType.SET)
    5513                        and self._parse_csv(self._parse_equality),
    5514                    )
    5515            elif self._match(TokenType.DELETE):
    5516                then = self.expression(exp.Var, this=self._prev.text)
    5517            else:
    5518                then = None
    5519
    5520            whens.append(
    5521                self.expression(
    5522                    exp.When,
    5523                    matched=matched,
    5524                    source=source,
    5525                    condition=condition,
    5526                    then=then,
    5527                )
    5528            )
    5529        return whens
    5530
    5531    def _parse_show(self) -> t.Optional[exp.Expression]:
    5532        parser = self._find_parser(self.SHOW_PARSERS, self.SHOW_TRIE)
    5533        if parser:
    5534            return parser(self)
    5535        return self._parse_as_command(self._prev)
    5536
    5537    def _parse_set_item_assignment(
    5538        self, kind: t.Optional[str] = None
    5539    ) -> t.Optional[exp.Expression]:
    5540        index = self._index
    5541
    5542        if kind in ("GLOBAL", "SESSION") and self._match_text_seq("TRANSACTION"):
    5543            return self._parse_set_transaction(global_=kind == "GLOBAL")
    5544
    5545        left = self._parse_primary() or self._parse_id_var()
    5546        assignment_delimiter = self._match_texts(("=", "TO"))
    5547
    5548        if not left or (self.SET_REQUIRES_ASSIGNMENT_DELIMITER and not assignment_delimiter):
    5549            self._retreat(index)
    5550            return None
    5551
    5552        right = self._parse_statement() or self._parse_id_var()
    5553        this = self.expression(exp.EQ, this=left, expression=right)
    5554
    5555        return self.expression(exp.SetItem, this=this, kind=kind)
    5556
    5557    def _parse_set_transaction(self, global_: bool = False) -> exp.Expression:
    5558        self._match_text_seq("TRANSACTION")
    5559        characteristics = self._parse_csv(
    5560            lambda: self._parse_var_from_options(self.TRANSACTION_CHARACTERISTICS)
    5561        )
    5562        return self.expression(
    5563            exp.SetItem,
    5564            expressions=characteristics,
    5565            kind="TRANSACTION",
    5566            **{"global": global_},  # type: ignore
    5567        )
    5568
    5569    def _parse_set_item(self) -> t.Optional[exp.Expression]:
    5570        parser = self._find_parser(self.SET_PARSERS, self.SET_TRIE)
    5571        return parser(self) if parser else self._parse_set_item_assignment(kind=None)
    5572
    5573    def _parse_set(self, unset: bool = False, tag: bool = False) -> exp.Set | exp.Command:
    5574        index = self._index
    5575        set_ = self.expression(
    5576            exp.Set, expressions=self._parse_csv(self._parse_set_item), unset=unset, tag=tag
    5577        )
    5578
    5579        if self._curr:
    5580            self._retreat(index)
    5581            return self._parse_as_command(self._prev)
    5582
    5583        return set_
    5584
    5585    def _parse_var_from_options(self, options: t.Collection[str]) -> t.Optional[exp.Var]:
    5586        for option in options:
    5587            if self._match_text_seq(*option.split(" ")):
    5588                return exp.var(option)
    5589        return None
    5590
    5591    def _parse_as_command(self, start: Token) -> exp.Command:
    5592        while self._curr:
    5593            self._advance()
    5594        text = self._find_sql(start, self._prev)
    5595        size = len(start.text)
    5596        self._warn_unsupported()
    5597        return exp.Command(this=text[:size], expression=text[size:])
    5598
    5599    def _parse_dict_property(self, this: str) -> exp.DictProperty:
    5600        settings = []
    5601
    5602        self._match_l_paren()
    5603        kind = self._parse_id_var()
    5604
    5605        if self._match(TokenType.L_PAREN):
    5606            while True:
    5607                key = self._parse_id_var()
    5608                value = self._parse_primary()
    5609
    5610                if not key and value is None:
    5611                    break
    5612                settings.append(self.expression(exp.DictSubProperty, this=key, value=value))
    5613            self._match(TokenType.R_PAREN)
    5614
    5615        self._match_r_paren()
    5616
    5617        return self.expression(
    5618            exp.DictProperty,
    5619            this=this,
    5620            kind=kind.this if kind else None,
    5621            settings=settings,
    5622        )
    5623
    5624    def _parse_dict_range(self, this: str) -> exp.DictRange:
    5625        self._match_l_paren()
    5626        has_min = self._match_text_seq("MIN")
    5627        if has_min:
    5628            min = self._parse_var() or self._parse_primary()
    5629            self._match_text_seq("MAX")
    5630            max = self._parse_var() or self._parse_primary()
    5631        else:
    5632            max = self._parse_var() or self._parse_primary()
    5633            min = exp.Literal.number(0)
    5634        self._match_r_paren()
    5635        return self.expression(exp.DictRange, this=this, min=min, max=max)
    5636
    5637    def _parse_comprehension(
    5638        self, this: t.Optional[exp.Expression]
    5639    ) -> t.Optional[exp.Comprehension]:
    5640        index = self._index
    5641        expression = self._parse_column()
    5642        if not self._match(TokenType.IN):
    5643            self._retreat(index - 1)
    5644            return None
    5645        iterator = self._parse_column()
    5646        condition = self._parse_conjunction() if self._match_text_seq("IF") else None
    5647        return self.expression(
    5648            exp.Comprehension,
    5649            this=this,
    5650            expression=expression,
    5651            iterator=iterator,
    5652            condition=condition,
    5653        )
    5654
    5655    def _parse_heredoc(self) -> t.Optional[exp.Heredoc]:
    5656        if self._match(TokenType.HEREDOC_STRING):
    5657            return self.expression(exp.Heredoc, this=self._prev.text)
    5658
    5659        if not self._match_text_seq("$"):
    5660            return None
    5661
    5662        tags = ["$"]
    5663        tag_text = None
    5664
    5665        if self._is_connected():
    5666            self._advance()
    5667            tags.append(self._prev.text.upper())
    5668        else:
    5669            self.raise_error("No closing $ found")
    5670
    5671        if tags[-1] != "$":
    5672            if self._is_connected() and self._match_text_seq("$"):
    5673                tag_text = tags[-1]
    5674                tags.append("$")
    5675            else:
    5676                self.raise_error("No closing $ found")
    5677
    5678        heredoc_start = self._curr
    5679
    5680        while self._curr:
    5681            if self._match_text_seq(*tags, advance=False):
    5682                this = self._find_sql(heredoc_start, self._prev)
    5683                self._advance(len(tags))
    5684                return self.expression(exp.Heredoc, this=this, tag=tag_text)
    5685
    5686            self._advance()
    5687
    5688        self.raise_error(f"No closing {''.join(tags)} found")
    5689        return None
    5690
    5691    def _find_parser(
    5692        self, parsers: t.Dict[str, t.Callable], trie: t.Dict
    5693    ) -> t.Optional[t.Callable]:
    5694        if not self._curr:
    5695            return None
    5696
    5697        index = self._index
    5698        this = []
    5699        while True:
    5700            # The current token might be multiple words
    5701            curr = self._curr.text.upper()
    5702            key = curr.split(" ")
    5703            this.append(curr)
    5704
    5705            self._advance()
    5706            result, trie = in_trie(trie, key)
    5707            if result == TrieResult.FAILED:
    5708                break
    5709
    5710            if result == TrieResult.EXISTS:
    5711                subparser = parsers[" ".join(this)]
    5712                return subparser
    5713
    5714        self._retreat(index)
    5715        return None
    5716
    5717    def _match(self, token_type, advance=True, expression=None):
    5718        if not self._curr:
    5719            return None
    5720
    5721        if self._curr.token_type == token_type:
    5722            if advance:
    5723                self._advance()
    5724            self._add_comments(expression)
    5725            return True
    5726
    5727        return None
    5728
    5729    def _match_set(self, types, advance=True):
    5730        if not self._curr:
    5731            return None
    5732
    5733        if self._curr.token_type in types:
    5734            if advance:
    5735                self._advance()
    5736            return True
    5737
    5738        return None
    5739
    5740    def _match_pair(self, token_type_a, token_type_b, advance=True):
    5741        if not self._curr or not self._next:
    5742            return None
    5743
    5744        if self._curr.token_type == token_type_a and self._next.token_type == token_type_b:
    5745            if advance:
    5746                self._advance(2)
    5747            return True
    5748
    5749        return None
    5750
    5751    def _match_l_paren(self, expression: t.Optional[exp.Expression] = None) -> None:
    5752        if not self._match(TokenType.L_PAREN, expression=expression):
    5753            self.raise_error("Expecting (")
    5754
    5755    def _match_r_paren(self, expression: t.Optional[exp.Expression] = None) -> None:
    5756        if not self._match(TokenType.R_PAREN, expression=expression):
    5757            self.raise_error("Expecting )")
    5758
    5759    def _match_texts(self, texts, advance=True):
    5760        if self._curr and self._curr.text.upper() in texts:
    5761            if advance:
    5762                self._advance()
    5763            return True
    5764        return None
    5765
    5766    def _match_text_seq(self, *texts, advance=True):
    5767        index = self._index
    5768        for text in texts:
    5769            if self._curr and self._curr.text.upper() == text:
    5770                self._advance()
    5771            else:
    5772                self._retreat(index)
    5773                return None
    5774
    5775        if not advance:
    5776            self._retreat(index)
    5777
    5778        return True
    5779
    5780    @t.overload
    5781    def _replace_columns_with_dots(self, this: exp.Expression) -> exp.Expression:
    5782        ...
    5783
    5784    @t.overload
    5785    def _replace_columns_with_dots(
    5786        self, this: t.Optional[exp.Expression]
    5787    ) -> t.Optional[exp.Expression]:
    5788        ...
    5789
    5790    def _replace_columns_with_dots(self, this):
    5791        if isinstance(this, exp.Dot):
    5792            exp.replace_children(this, self._replace_columns_with_dots)
    5793        elif isinstance(this, exp.Column):
    5794            exp.replace_children(this, self._replace_columns_with_dots)
    5795            table = this.args.get("table")
    5796            this = (
    5797                self.expression(exp.Dot, this=table, expression=this.this) if table else this.this
    5798            )
    5799
    5800        return this
    5801
    5802    def _replace_lambda(
    5803        self, node: t.Optional[exp.Expression], lambda_variables: t.Set[str]
    5804    ) -> t.Optional[exp.Expression]:
    5805        if not node:
    5806            return node
    5807
    5808        for column in node.find_all(exp.Column):
    5809            if column.parts[0].name in lambda_variables:
    5810                dot_or_id = column.to_dot() if column.table else column.this
    5811                parent = column.parent
    5812
    5813                while isinstance(parent, exp.Dot):
    5814                    if not isinstance(parent.parent, exp.Dot):
    5815                        parent.replace(dot_or_id)
    5816                        break
    5817                    parent = parent.parent
    5818                else:
    5819                    if column is node:
    5820                        node = dot_or_id
    5821                    else:
    5822                        column.replace(dot_or_id)
    5823        return node

Parser consumes a list of tokens produced by the Tokenizer and produces a parsed syntax tree.

###### Arguments:

- error_level: The desired error level. Default: ErrorLevel.IMMEDIATE
- error_message_context: Determines the amount of context to capture from a query string when displaying the error message (in number of characters). Default: 100
- max_errors: Maximum number of error messages to include in a raised ParseError. This is only relevant if error_level is ErrorLevel.RAISE. Default: 3

Parser( error_level: Optional[sqlglot.errors.ErrorLevel] = None, error_message_context: int = 100, max_errors: int = 3, dialect: Union[str, sqlglot.dialects.dialect.Dialect, Type[sqlglot.dialects.dialect.Dialect], NoneType] = None) View Source

    1027    def __init__(
    1028        self,
    1029        error_level: t.Optional[ErrorLevel] = None,
    1030        error_message_context: int = 100,
    1031        max_errors: int = 3,
    1032        dialect: DialectType = None,
    1033    ):
    1034        from sqlglot.dialects import Dialect
    1035
    1036        self.error_level = error_level or ErrorLevel.IMMEDIATE
    1037        self.error_message_context = error_message_context
    1038        self.max_errors = max_errors
    1039        self.dialect = Dialect.get_or_raise(dialect)
    1040        self.reset()

FUNCTIONS: Dict[str, Callable] = {'ABS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Abs'>>, 'ANONYMOUS_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnonymousAggFunc'>>, 'ANY_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnyValue'>>, 'APPROX_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'APPROX_COUNT_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'APPROX_QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxQuantile'>>, 'APPROX_TOP_K': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxTopK'>>, 'ARG_MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'ARGMAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'MAX_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'ARG_MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'ARGMIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'MIN_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Array'>>, 'ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAgg'>>, 'ARRAY_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAll'>>, 'ARRAY_ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAny'>>, 'ARRAY_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcat'>>, 'ARRAY_CAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcat'>>, 'ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContains'>>, 'FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayFilter'>>, 'ARRAY_FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayFilter'>>, 'ARRAY_JOIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayJoin'>>, 'ARRAY_OVERLAPS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayOverlaps'>>, 'ARRAY_SIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySize'>>, 'ARRAY_SORT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySort'>>, 'ARRAY_SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySum'>>, 'ARRAY_UNION_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUnionAgg'>>, 'ARRAY_UNIQUE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUniqueAgg'>>, 'AVG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Avg'>>, 'CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Case'>>, 'CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Cast'>>, 'CAST_TO_STR_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CastToStrType'>>, 'CEIL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ceil'>>, 'CEILING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ceil'>>, 'CHR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Chr'>>, 'CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Chr'>>, 'COALESCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'IFNULL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'NVL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'COLLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Collate'>>, 'COMBINED_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CombinedAggFunc'>>, 'COMBINED_PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CombinedParameterizedAgg'>>, 'CONCAT': <function Parser.<lambda>>, 'CONCAT_WS': <function Parser.<lambda>>, 'COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Count'>>, 'COUNT_IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CountIf'>>, 'COUNTIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CountIf'>>, 'CURRENT_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentDate'>>, 'CURRENT_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentDatetime'>>, 'CURRENT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTime'>>, 'CURRENT_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTimestamp'>>, 'CURRENT_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentUser'>>, 'DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Date'>>, 'DATE_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateAdd'>>, 'DATEDIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateDiff'>>, 'DATE_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateDiff'>>, 'DATE_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateFromParts'>>, 'DATEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateFromParts'>>, 'DATE_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateStrToDate'>>, 'DATE_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateSub'>>, 'DATE_TO_DATE_STR': <function Parser.<lambda>>, 'DATE_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateToDi'>>, 'DATE_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateTrunc'>>, 'DATETIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeAdd'>>, 'DATETIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeDiff'>>, 'DATETIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeSub'>>, 'DATETIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeTrunc'>>, 'DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Day'>>, 'DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfMonth'>>, 'DAYOFMONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfMonth'>>, 'DAY_OF_WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeek'>>, 'DAYOFWEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeek'>>, 'DAY_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfYear'>>, 'DAYOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfYear'>>, 'DECODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Decode'>>, 'DI_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DiToDate'>>, 'ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Encode'>>, 'EXP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Exp'>>, 'EXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Explode'>>, 'EXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ExplodeOuter'>>, 'EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Extract'>>, 'FIRST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.First'>>, 'FIRST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FirstValue'>>, 'FLATTEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Flatten'>>, 'FLOOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Floor'>>, 'FROM_BASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase'>>, 'FROM_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase64'>>, 'GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateSeries'>>, 'GREATEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Greatest'>>, 'GROUP_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GroupConcat'>>, 'HEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Hex'>>, 'HLL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Hll'>>, 'IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.If'>>, 'INITCAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Initcap'>>, 'IS_INF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsInf'>>, 'ISINF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsInf'>>, 'IS_NAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsNan'>>, 'ISNAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsNan'>>, 'J_S_O_N_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArray'>>, 'J_S_O_N_ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayAgg'>>, 'JSON_ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayContains'>>, 'JSONB_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExtract'>>, 'JSONB_EXTRACT_SCALAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExtractScalar'>>, 'JSON_EXTRACT': <function parse_extract_json_with_path.<locals>._parser>, 'JSON_EXTRACT_SCALAR': <function parse_extract_json_with_path.<locals>._parser>, 'JSON_FORMAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONFormat'>>, 'J_S_O_N_OBJECT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONObject'>>, 'J_S_O_N_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONObjectAgg'>>, 'J_S_O_N_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONTable'>>, 'LAG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lag'>>, 'LAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Last'>>, 'LAST_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastDay'>>, 'LAST_DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastDay'>>, 'LAST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastValue'>>, 'LEAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lead'>>, 'LEAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Least'>>, 'LEFT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Left'>>, 'LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'LEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'LEVENSHTEIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Levenshtein'>>, 'LN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ln'>>, 'LOG': <function parse_logarithm>, 'LOG10': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Log10'>>, 'LOG2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Log2'>>, 'LOGICAL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'BOOL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'BOOLAND_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'LOGICAL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'BOOL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'BOOLOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'LOWER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lower'>>, 'LCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lower'>>, 'MD5': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5'>>, 'MD5_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5Digest'>>, 'MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Map'>>, 'MAP_FROM_ENTRIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MapFromEntries'>>, 'MATCH_AGAINST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MatchAgainst'>>, 'MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Max'>>, 'MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Min'>>, 'MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Month'>>, 'MONTHS_BETWEEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MonthsBetween'>>, 'NEXT_VALUE_FOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NextValueFor'>>, 'NTH_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NthValue'>>, 'NULLIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Nullif'>>, 'NUMBER_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NumberToStr'>>, 'NVL2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Nvl2'>>, 'OPEN_J_S_O_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.OpenJSON'>>, 'PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParameterizedAgg'>>, 'PARSE_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseJSON'>>, 'JSON_PARSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseJSON'>>, 'PERCENTILE_CONT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentileCont'>>, 'PERCENTILE_DISC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentileDisc'>>, 'POSEXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Posexplode'>>, 'POSEXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PosexplodeOuter'>>, 'POWER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pow'>>, 'POW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pow'>>, 'PREDICT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Predict'>>, 'QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Quantile'>>, 'RAND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'RANDOM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'RANDN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Randn'>>, 'RANGE_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RangeN'>>, 'READ_CSV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ReadCSV'>>, 'REDUCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Reduce'>>, 'REGEXP_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpExtract'>>, 'REGEXP_I_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpILike'>>, 'REGEXP_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpLike'>>, 'REGEXP_REPLACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpReplace'>>, 'REGEXP_SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpSplit'>>, 'REPEAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Repeat'>>, 'RIGHT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Right'>>, 'ROUND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Round'>>, 'ROW_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RowNumber'>>, 'SHA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA'>>, 'SHA1': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA'>>, 'SHA2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA2'>>, 'SAFE_DIVIDE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SafeDivide'>>, 'SORT_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SortArray'>>, 'SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Split'>>, 'SQRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sqrt'>>, 'STANDARD_HASH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StandardHash'>>, 'STAR_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StarMap'>>, 'STARTS_WITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StartsWith'>>, 'STARTSWITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StartsWith'>>, 'STDDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stddev'>>, 'STDDEV_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StddevPop'>>, 'STDDEV_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StddevSamp'>>, 'STR_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrPosition'>>, 'STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToDate'>>, 'STR_TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToMap'>>, 'STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToTime'>>, 'STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToUnix'>>, 'STRUCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Struct'>>, 'STRUCT_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StructExtract'>>, 'STUFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stuff'>>, 'INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stuff'>>, 'SUBSTRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Substring'>>, 'SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sum'>>, 'TIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeAdd'>>, 'TIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeDiff'>>, 'TIME_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'TIMEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'TIME_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToDate'>>, 'TIME_STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToTime'>>, 'TIME_STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToUnix'>>, 'TIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeSub'>>, 'TIME_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeToStr'>>, 'TIME_TO_TIME_STR': <function Parser.<lambda>>, 'TIME_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeToUnix'>>, 'TIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeTrunc'>>, 'TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Timestamp'>>, 'TIMESTAMP_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampAdd'>>, 'TIMESTAMPDIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampDiff'>>, 'TIMESTAMP_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampDiff'>>, 'TIMESTAMP_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampFromParts'>>, 'TIMESTAMPFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampFromParts'>>, 'TIMESTAMP_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampSub'>>, 'TIMESTAMP_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampTrunc'>>, 'TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToArray'>>, 'TO_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToBase64'>>, 'TO_CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToChar'>>, 'TO_DAYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToDays'>>, 'TRANSFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Transform'>>, 'TRIM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Trim'>>, 'TRY_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TryCast'>>, 'TS_OR_DI_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDiToDi'>>, 'TS_OR_DS_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsAdd'>>, 'TS_OR_DS_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsDiff'>>, 'TS_OR_DS_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToDate'>>, 'TS_OR_DS_TO_DATE_STR': <function Parser.<lambda>>, 'TS_OR_DS_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToTime'>>, 'UNHEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Unhex'>>, 'UNIX_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixDate'>>, 'UNIX_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToStr'>>, 'UNIX_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToTime'>>, 'UNIX_TO_TIME_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToTimeStr'>>, 'UPPER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Upper'>>, 'UCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Upper'>>, 'VAR_MAP': <function parse_var_map>, 'VARIANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VARIANCE_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VARIANCE_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VariancePop'>>, 'VAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VariancePop'>>, 'WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Week'>>, 'WEEK_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.WeekOfYear'>>, 'WEEKOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.WeekOfYear'>>, 'WHEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.When'>>, 'X_M_L_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.XMLTable'>>, 'XOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Xor'>>, 'YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Year'>>, 'GLOB': <function Parser.<lambda>>, 'JSON_EXTRACT_PATH_TEXT': <function parse_extract_json_with_path.<locals>._parser>, 'LIKE': <function parse_like>}
NO_PAREN_FUNCTIONS = {<TokenType.CURRENT_DATE: 'CURRENT_DATE'>: <class 'sqlglot.expressions.CurrentDate'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>: <class 'sqlglot.expressions.CurrentDate'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>: <class 'sqlglot.expressions.CurrentTime'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>: <class 'sqlglot.expressions.CurrentTimestamp'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>: <class 'sqlglot.expressions.CurrentUser'>}
STRUCT_TYPE_TOKENS = {<TokenType.STRUCT: 'STRUCT'>, <TokenType.NESTED: 'NESTED'>}
NESTED_TYPE_TOKENS = {<TokenType.STRUCT: 'STRUCT'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.MAP: 'MAP'>, <TokenType.NESTED: 'NESTED'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.NULLABLE: 'NULLABLE'>}
ENUM_TYPE_TOKENS = {<TokenType.ENUM16: 'ENUM16'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.ENUM: 'ENUM'>}
AGGREGATE_TYPE_TOKENS = {<TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>}
TYPE_TOKENS = {<TokenType.NULL: 'NULL'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.XML: 'XML'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.IPV4: 'IPV4'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.INT128: 'INT128'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.MAP: 'MAP'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.TEXT: 'TEXT'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.BINARY: 'BINARY'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.TIME: 'TIME'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.UINT256: 'UINT256'>, <TokenType.DATE32: 'DATE32'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.INET: 'INET'>, <TokenType.NESTED: 'NESTED'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.IPV6: 'IPV6'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.MONEY: 'MONEY'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.BIT: 'BIT'>, <TokenType.DATE: 'DATE'>, <TokenType.SUPER: 'SUPER'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.INT256: 'INT256'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.UINT: 'UINT'>, <TokenType.UINT128: 'UINT128'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.INT: 'INT'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.JSON: 'JSON'>, <TokenType.JSONB: 'JSONB'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.YEAR: 'YEAR'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ENUM: 'ENUM'>, <TokenType.CHAR: 'CHAR'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.DOUBLE: 'DOUBLE'>}
SIGNED_TO_UNSIGNED_TYPE_TOKEN = {<TokenType.BIGINT: 'BIGINT'>: <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.INT: 'INT'>: <TokenType.UINT: 'UINT'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>: <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.SMALLINT: 'SMALLINT'>: <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.TINYINT: 'TINYINT'>: <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.DECIMAL: 'DECIMAL'>: <TokenType.UDECIMAL: 'UDECIMAL'>}
SUBQUERY_PREDICATES = {<TokenType.ANY: 'ANY'>: <class 'sqlglot.expressions.Any'>, <TokenType.ALL: 'ALL'>: <class 'sqlglot.expressions.All'>, <TokenType.EXISTS: 'EXISTS'>: <class 'sqlglot.expressions.Exists'>, <TokenType.SOME: 'SOME'>: <class 'sqlglot.expressions.Any'>}
RESERVED_TOKENS = {<TokenType.STAR: 'STAR'>, <TokenType.L_BRACKET: 'L_BRACKET'>, <TokenType.NOT: 'NOT'>, <TokenType.CARET: 'CARET'>, <TokenType.GT: 'GT'>, <TokenType.PLACEHOLDER: 'PLACEHOLDER'>, <TokenType.LT: 'LT'>, <TokenType.PIPE: 'PIPE'>, <TokenType.R_BRACKET: 'R_BRACKET'>, <TokenType.QUOTE: 'QUOTE'>, <TokenType.L_BRACE: 'L_BRACE'>, <TokenType.L_PAREN: 'L_PAREN'>, <TokenType.AMP: 'AMP'>, <TokenType.DOT: 'DOT'>, <TokenType.BACKSLASH: 'BACKSLASH'>, <TokenType.R_BRACE: 'R_BRACE'>, <TokenType.SEMICOLON: 'SEMICOLON'>, <TokenType.PARAMETER: 'PARAMETER'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.SLASH: 'SLASH'>, <TokenType.TILDA: 'TILDA'>, <TokenType.COLON: 'COLON'>, <TokenType.EQ: 'EQ'>, <TokenType.DASH: 'DASH'>, <TokenType.PLUS: 'PLUS'>, <TokenType.SELECT: 'SELECT'>, <TokenType.HASH: 'HASH'>, <TokenType.R_PAREN: 'R_PAREN'>, <TokenType.COMMA: 'COMMA'>, <TokenType.MOD: 'MOD'>}
DB_CREATABLES = {<TokenType.TABLE: 'TABLE'>, <TokenType.VIEW: 'VIEW'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.MODEL: 'MODEL'>, <TokenType.DATABASE: 'DATABASE'>}
CREATABLES = {<TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.INDEX: 'INDEX'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.TABLE: 'TABLE'>, <TokenType.VIEW: 'VIEW'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.MODEL: 'MODEL'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>}
ID_VAR_TOKENS = {<TokenType.NULL: 'NULL'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.XML: 'XML'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.END: 'END'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.LOAD: 'LOAD'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.LEFT: 'LEFT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.IPV4: 'IPV4'>, <TokenType.ROWS: 'ROWS'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.SEMI: 'SEMI'>, <TokenType.INT128: 'INT128'>, <TokenType.SHOW: 'SHOW'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.FALSE: 'FALSE'>, <TokenType.MODEL: 'MODEL'>, <TokenType.ANTI: 'ANTI'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.MAP: 'MAP'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.TABLE: 'TABLE'>, <TokenType.TEXT: 'TEXT'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.BINARY: 'BINARY'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.SET: 'SET'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.NATURAL: 'NATURAL'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.NEXT: 'NEXT'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.FILTER: 'FILTER'>, <TokenType.TIME: 'TIME'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.UINT256: 'UINT256'>, <TokenType.DATE32: 'DATE32'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.INET: 'INET'>, <TokenType.APPLY: 'APPLY'>, <TokenType.DESC: 'DESC'>, <TokenType.NESTED: 'NESTED'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.ALL: 'ALL'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.RANGE: 'RANGE'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.IPV6: 'IPV6'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.KEEP: 'KEEP'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.DELETE: 'DELETE'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.ROW: 'ROW'>, <TokenType.MONEY: 'MONEY'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.BIT: 'BIT'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.DATE: 'DATE'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.VAR: 'VAR'>, <TokenType.SUPER: 'SUPER'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.INT256: 'INT256'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.TRUE: 'TRUE'>, <TokenType.SOME: 'SOME'>, <TokenType.UINT: 'UINT'>, <TokenType.UINT128: 'UINT128'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.CASE: 'CASE'>, <TokenType.IS: 'IS'>, <TokenType.INT: 'INT'>, <TokenType.FULL: 'FULL'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.MERGE: 'MERGE'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.FINAL: 'FINAL'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.JSON: 'JSON'>, <TokenType.JSONB: 'JSONB'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.INDEX: 'INDEX'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.USE: 'USE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.ASC: 'ASC'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.KILL: 'KILL'>, <TokenType.CACHE: 'CACHE'>, <TokenType.ANY: 'ANY'>, <TokenType.YEAR: 'YEAR'>, <TokenType.VIEW: 'VIEW'>, <TokenType.FIRST: 'FIRST'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.DIV: 'DIV'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ENUM: 'ENUM'>, <TokenType.TOP: 'TOP'>, <TokenType.CHAR: 'CHAR'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.FUNCTION: 'FUNCTION'>}
INTERVAL_VARS = {<TokenType.NULL: 'NULL'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.XML: 'XML'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.LOAD: 'LOAD'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.LEFT: 'LEFT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.IPV4: 'IPV4'>, <TokenType.ROWS: 'ROWS'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.SEMI: 'SEMI'>, <TokenType.INT128: 'INT128'>, <TokenType.SHOW: 'SHOW'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.FALSE: 'FALSE'>, <TokenType.MODEL: 'MODEL'>, <TokenType.ANTI: 'ANTI'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.MAP: 'MAP'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.TABLE: 'TABLE'>, <TokenType.TEXT: 'TEXT'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.BINARY: 'BINARY'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.SET: 'SET'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.NATURAL: 'NATURAL'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.NEXT: 'NEXT'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.FILTER: 'FILTER'>, <TokenType.TIME: 'TIME'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.UINT256: 'UINT256'>, <TokenType.DATE32: 'DATE32'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.INET: 'INET'>, <TokenType.APPLY: 'APPLY'>, <TokenType.DESC: 'DESC'>, <TokenType.NESTED: 'NESTED'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.ALL: 'ALL'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.RANGE: 'RANGE'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.IPV6: 'IPV6'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.KEEP: 'KEEP'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.DELETE: 'DELETE'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.ROW: 'ROW'>, <TokenType.MONEY: 'MONEY'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.BIT: 'BIT'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.DATE: 'DATE'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.VAR: 'VAR'>, <TokenType.SUPER: 'SUPER'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.INT256: 'INT256'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.TRUE: 'TRUE'>, <TokenType.SOME: 'SOME'>, <TokenType.UINT: 'UINT'>, <TokenType.UINT128: 'UINT128'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.CASE: 'CASE'>, <TokenType.IS: 'IS'>, <TokenType.INT: 'INT'>, <TokenType.FULL: 'FULL'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.MERGE: 'MERGE'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.FINAL: 'FINAL'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.JSON: 'JSON'>, <TokenType.JSONB: 'JSONB'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.INDEX: 'INDEX'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.USE: 'USE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.ASC: 'ASC'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.KILL: 'KILL'>, <TokenType.CACHE: 'CACHE'>, <TokenType.ANY: 'ANY'>, <TokenType.YEAR: 'YEAR'>, <TokenType.VIEW: 'VIEW'>, <TokenType.FIRST: 'FIRST'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.DIV: 'DIV'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ENUM: 'ENUM'>, <TokenType.TOP: 'TOP'>, <TokenType.CHAR: 'CHAR'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.FUNCTION: 'FUNCTION'>}
TABLE_ALIAS_TOKENS = {<TokenType.NULL: 'NULL'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.XML: 'XML'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.END: 'END'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.LOAD: 'LOAD'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.IPV4: 'IPV4'>, <TokenType.ROWS: 'ROWS'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.INT128: 'INT128'>, <TokenType.SHOW: 'SHOW'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.FALSE: 'FALSE'>, <TokenType.MODEL: 'MODEL'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.MAP: 'MAP'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.TABLE: 'TABLE'>, <TokenType.TEXT: 'TEXT'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.BINARY: 'BINARY'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.SET: 'SET'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.NEXT: 'NEXT'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.FILTER: 'FILTER'>, <TokenType.TIME: 'TIME'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.UINT256: 'UINT256'>, <TokenType.DATE32: 'DATE32'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.INET: 'INET'>, <TokenType.DESC: 'DESC'>, <TokenType.NESTED: 'NESTED'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.ALL: 'ALL'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.RANGE: 'RANGE'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.IPV6: 'IPV6'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.KEEP: 'KEEP'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.DELETE: 'DELETE'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.ROW: 'ROW'>, <TokenType.MONEY: 'MONEY'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.BIT: 'BIT'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.DATE: 'DATE'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.VAR: 'VAR'>, <TokenType.SUPER: 'SUPER'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.INT256: 'INT256'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TRUE: 'TRUE'>, <TokenType.SOME: 'SOME'>, <TokenType.UINT: 'UINT'>, <TokenType.UINT128: 'UINT128'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.CASE: 'CASE'>, <TokenType.IS: 'IS'>, <TokenType.INT: 'INT'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.MERGE: 'MERGE'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.FINAL: 'FINAL'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.JSON: 'JSON'>, <TokenType.JSONB: 'JSONB'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.INDEX: 'INDEX'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.USE: 'USE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.ASC: 'ASC'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.KILL: 'KILL'>, <TokenType.CACHE: 'CACHE'>, <TokenType.ANY: 'ANY'>, <TokenType.YEAR: 'YEAR'>, <TokenType.VIEW: 'VIEW'>, <TokenType.FIRST: 'FIRST'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.DIV: 'DIV'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ENUM: 'ENUM'>, <TokenType.TOP: 'TOP'>, <TokenType.CHAR: 'CHAR'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.FUNCTION: 'FUNCTION'>}
COMMENT_TABLE_ALIAS_TOKENS = {<TokenType.NULL: 'NULL'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.XML: 'XML'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.END: 'END'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.LOAD: 'LOAD'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.IPV4: 'IPV4'>, <TokenType.ROWS: 'ROWS'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.INT128: 'INT128'>, <TokenType.SHOW: 'SHOW'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.FALSE: 'FALSE'>, <TokenType.MODEL: 'MODEL'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.MAP: 'MAP'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.TABLE: 'TABLE'>, <TokenType.TEXT: 'TEXT'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.BINARY: 'BINARY'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.SET: 'SET'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.NEXT: 'NEXT'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.FILTER: 'FILTER'>, <TokenType.TIME: 'TIME'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.UINT256: 'UINT256'>, <TokenType.DATE32: 'DATE32'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.INET: 'INET'>, <TokenType.DESC: 'DESC'>, <TokenType.NESTED: 'NESTED'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.ALL: 'ALL'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.RANGE: 'RANGE'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.IPV6: 'IPV6'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.KEEP: 'KEEP'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.DELETE: 'DELETE'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.ROW: 'ROW'>, <TokenType.MONEY: 'MONEY'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.BIT: 'BIT'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.DATE: 'DATE'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.VAR: 'VAR'>, <TokenType.SUPER: 'SUPER'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.INT256: 'INT256'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TRUE: 'TRUE'>, <TokenType.SOME: 'SOME'>, <TokenType.UINT: 'UINT'>, <TokenType.UINT128: 'UINT128'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.CASE: 'CASE'>, <TokenType.INT: 'INT'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.MERGE: 'MERGE'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.FINAL: 'FINAL'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.JSON: 'JSON'>, <TokenType.JSONB: 'JSONB'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.INDEX: 'INDEX'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.USE: 'USE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.ASC: 'ASC'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.KILL: 'KILL'>, <TokenType.CACHE: 'CACHE'>, <TokenType.ANY: 'ANY'>, <TokenType.YEAR: 'YEAR'>, <TokenType.VIEW: 'VIEW'>, <TokenType.FIRST: 'FIRST'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.DIV: 'DIV'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ENUM: 'ENUM'>, <TokenType.TOP: 'TOP'>, <TokenType.CHAR: 'CHAR'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.FUNCTION: 'FUNCTION'>}
UPDATE_ALIAS_TOKENS = {<TokenType.NULL: 'NULL'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.XML: 'XML'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.END: 'END'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.LOAD: 'LOAD'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.IPV4: 'IPV4'>, <TokenType.ROWS: 'ROWS'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.INT128: 'INT128'>, <TokenType.SHOW: 'SHOW'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.FALSE: 'FALSE'>, <TokenType.MODEL: 'MODEL'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.MAP: 'MAP'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.TABLE: 'TABLE'>, <TokenType.TEXT: 'TEXT'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.BINARY: 'BINARY'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.NEXT: 'NEXT'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.FILTER: 'FILTER'>, <TokenType.TIME: 'TIME'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.UINT256: 'UINT256'>, <TokenType.DATE32: 'DATE32'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.INET: 'INET'>, <TokenType.DESC: 'DESC'>, <TokenType.NESTED: 'NESTED'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.ALL: 'ALL'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.RANGE: 'RANGE'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.IPV6: 'IPV6'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.KEEP: 'KEEP'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.DELETE: 'DELETE'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.ROW: 'ROW'>, <TokenType.MONEY: 'MONEY'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.BIT: 'BIT'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.DATE: 'DATE'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.VAR: 'VAR'>, <TokenType.SUPER: 'SUPER'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.INT256: 'INT256'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TRUE: 'TRUE'>, <TokenType.SOME: 'SOME'>, <TokenType.UINT: 'UINT'>, <TokenType.UINT128: 'UINT128'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.CASE: 'CASE'>, <TokenType.IS: 'IS'>, <TokenType.INT: 'INT'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.MERGE: 'MERGE'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.FINAL: 'FINAL'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.JSON: 'JSON'>, <TokenType.JSONB: 'JSONB'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.INDEX: 'INDEX'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.USE: 'USE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.ASC: 'ASC'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.KILL: 'KILL'>, <TokenType.CACHE: 'CACHE'>, <TokenType.ANY: 'ANY'>, <TokenType.YEAR: 'YEAR'>, <TokenType.VIEW: 'VIEW'>, <TokenType.FIRST: 'FIRST'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.DIV: 'DIV'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ENUM: 'ENUM'>, <TokenType.TOP: 'TOP'>, <TokenType.CHAR: 'CHAR'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.FUNCTION: 'FUNCTION'>}
TRIM_TYPES = {'TRAILING', 'LEADING', 'BOTH'}
FUNC_TOKENS = {<TokenType.NULL: 'NULL'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.XML: 'XML'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.GLOB: 'GLOB'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.LEFT: 'LEFT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.IPV4: 'IPV4'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.INT128: 'INT128'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.MAP: 'MAP'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.TABLE: 'TABLE'>, <TokenType.TEXT: 'TEXT'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.BINARY: 'BINARY'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.FILTER: 'FILTER'>, <TokenType.TIME: 'TIME'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.UINT256: 'UINT256'>, <TokenType.DATE32: 'DATE32'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.INET: 'INET'>, <TokenType.NESTED: 'NESTED'>, <TokenType.INSERT: 'INSERT'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.ALL: 'ALL'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.RANGE: 'RANGE'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.IPV6: 'IPV6'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.RLIKE: 'RLIKE'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.ROW: 'ROW'>, <TokenType.MONEY: 'MONEY'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.BIT: 'BIT'>, <TokenType.DATE: 'DATE'>, <TokenType.XOR: 'XOR'>, <TokenType.PRIMARY_KEY: 'PRIMARY_KEY'>, <TokenType.VAR: 'VAR'>, <TokenType.SUPER: 'SUPER'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.INT256: 'INT256'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.UINT: 'UINT'>, <TokenType.SOME: 'SOME'>, <TokenType.UINT128: 'UINT128'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.LIKE: 'LIKE'>, <TokenType.INT: 'INT'>, <TokenType.MERGE: 'MERGE'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.JSON: 'JSON'>, <TokenType.JSONB: 'JSONB'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.INDEX: 'INDEX'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.ANY: 'ANY'>, <TokenType.YEAR: 'YEAR'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.FIRST: 'FIRST'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ILIKE: 'ILIKE'>, <TokenType.ENUM: 'ENUM'>, <TokenType.CHAR: 'CHAR'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.DOUBLE: 'DOUBLE'>}
CONJUNCTION = {<TokenType.AND: 'AND'>: <class 'sqlglot.expressions.And'>, <TokenType.OR: 'OR'>: <class 'sqlglot.expressions.Or'>}
EQUALITY = {<TokenType.COLON_EQ: 'COLON_EQ'>: <class 'sqlglot.expressions.PropertyEQ'>, <TokenType.EQ: 'EQ'>: <class 'sqlglot.expressions.EQ'>, <TokenType.NEQ: 'NEQ'>: <class 'sqlglot.expressions.NEQ'>, <TokenType.NULLSAFE_EQ: 'NULLSAFE_EQ'>: <class 'sqlglot.expressions.NullSafeEQ'>}
COMPARISON = {<TokenType.GT: 'GT'>: <class 'sqlglot.expressions.GT'>, <TokenType.GTE: 'GTE'>: <class 'sqlglot.expressions.GTE'>, <TokenType.LT: 'LT'>: <class 'sqlglot.expressions.LT'>, <TokenType.LTE: 'LTE'>: <class 'sqlglot.expressions.LTE'>}
BITWISE = {<TokenType.AMP: 'AMP'>: <class 'sqlglot.expressions.BitwiseAnd'>, <TokenType.CARET: 'CARET'>: <class 'sqlglot.expressions.BitwiseXor'>, <TokenType.PIPE: 'PIPE'>: <class 'sqlglot.expressions.BitwiseOr'>}
TERM = {<TokenType.DASH: 'DASH'>: <class 'sqlglot.expressions.Sub'>, <TokenType.PLUS: 'PLUS'>: <class 'sqlglot.expressions.Add'>, <TokenType.MOD: 'MOD'>: <class 'sqlglot.expressions.Mod'>, <TokenType.COLLATE: 'COLLATE'>: <class 'sqlglot.expressions.Collate'>}
FACTOR = {<TokenType.DIV: 'DIV'>: <class 'sqlglot.expressions.IntDiv'>, <TokenType.LR_ARROW: 'LR_ARROW'>: <class 'sqlglot.expressions.Distance'>, <TokenType.SLASH: 'SLASH'>: <class 'sqlglot.expressions.Div'>, <TokenType.STAR: 'STAR'>: <class 'sqlglot.expressions.Mul'>}
EXPONENT: Dict[sqlglot.tokens.TokenType, Type[sqlglot.expressions.Expression]] = {}
TIMES = {<TokenType.TIMETZ: 'TIMETZ'>, <TokenType.TIME: 'TIME'>}
TIMESTAMPS = {<TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.TIME: 'TIME'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>}
SET_OPERATIONS = {<TokenType.EXCEPT: 'EXCEPT'>, <TokenType.INTERSECT: 'INTERSECT'>, <TokenType.UNION: 'UNION'>}
JOIN_METHODS = {<TokenType.NATURAL: 'NATURAL'>, <TokenType.ASOF: 'ASOF'>}
JOIN_SIDES = {<TokenType.FULL: 'FULL'>, <TokenType.LEFT: 'LEFT'>, <TokenType.RIGHT: 'RIGHT'>}
JOIN_KINDS = {<TokenType.INNER: 'INNER'>, <TokenType.SEMI: 'SEMI'>, <TokenType.CROSS: 'CROSS'>, <TokenType.OUTER: 'OUTER'>, <TokenType.ANTI: 'ANTI'>}
JOIN_HINTS: Set[str] = set()
LAMBDAS = {<TokenType.ARROW: 'ARROW'>: <function Parser.<lambda>>, <TokenType.FARROW: 'FARROW'>: <function Parser.<lambda>>}
COLUMN_OPERATORS = {<TokenType.DOT: 'DOT'>: None, <TokenType.DCOLON: 'DCOLON'>: <function Parser.<lambda>>, <TokenType.ARROW: 'ARROW'>: <function Parser.<lambda>>, <TokenType.DARROW: 'DARROW'>: <function Parser.<lambda>>, <TokenType.HASH_ARROW: 'HASH_ARROW'>: <function Parser.<lambda>>, <TokenType.DHASH_ARROW: 'DHASH_ARROW'>: <function Parser.<lambda>>, <TokenType.PLACEHOLDER: 'PLACEHOLDER'>: <function Parser.<lambda>>}
EXPRESSION_PARSERS = {<class 'sqlglot.expressions.Cluster'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Column'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Condition'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.DataType'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Expression'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.From'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Group'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Having'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Identifier'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Join'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Lambda'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Lateral'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Limit'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Offset'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Order'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Ordered'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Properties'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Qualify'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Returning'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Sort'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Table'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.TableAlias'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.When'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Where'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.Window'>: <function Parser.<lambda>>, <class 'sqlglot.expressions.With'>: <function Parser.<lambda>>, 'JOIN_TYPE': <function Parser.<lambda>>}
STATEMENT_PARSERS = {<TokenType.ALTER: 'ALTER'>: <function Parser.<lambda>>, <TokenType.BEGIN: 'BEGIN'>: <function Parser.<lambda>>, <TokenType.CACHE: 'CACHE'>: <function Parser.<lambda>>, <TokenType.COMMIT: 'COMMIT'>: <function Parser.<lambda>>, <TokenType.COMMENT: 'COMMENT'>: <function Parser.<lambda>>, <TokenType.CREATE: 'CREATE'>: <function Parser.<lambda>>, <TokenType.DELETE: 'DELETE'>: <function Parser.<lambda>>, <TokenType.DESC: 'DESC'>: <function Parser.<lambda>>, <TokenType.DESCRIBE: 'DESCRIBE'>: <function Parser.<lambda>>, <TokenType.DROP: 'DROP'>: <function Parser.<lambda>>, <TokenType.INSERT: 'INSERT'>: <function Parser.<lambda>>, <TokenType.KILL: 'KILL'>: <function Parser.<lambda>>, <TokenType.LOAD: 'LOAD'>: <function Parser.<lambda>>, <TokenType.MERGE: 'MERGE'>: <function Parser.<lambda>>, <TokenType.PIVOT: 'PIVOT'>: <function Parser.<lambda>>, <TokenType.PRAGMA: 'PRAGMA'>: <function Parser.<lambda>>, <TokenType.REFRESH: 'REFRESH'>: <function Parser.<lambda>>, <TokenType.ROLLBACK: 'ROLLBACK'>: <function Parser.<lambda>>, <TokenType.SET: 'SET'>: <function Parser.<lambda>>, <TokenType.UNCACHE: 'UNCACHE'>: <function Parser.<lambda>>, <TokenType.UPDATE: 'UPDATE'>: <function Parser.<lambda>>, <TokenType.USE: 'USE'>: <function Parser.<lambda>>}
UNARY_PARSERS = {<TokenType.PLUS: 'PLUS'>: <function Parser.<lambda>>, <TokenType.NOT: 'NOT'>: <function Parser.<lambda>>, <TokenType.TILDA: 'TILDA'>: <function Parser.<lambda>>, <TokenType.DASH: 'DASH'>: <function Parser.<lambda>>}
PRIMARY_PARSERS = {<TokenType.STRING: 'STRING'>: <function Parser.<lambda>>, <TokenType.NUMBER: 'NUMBER'>: <function Parser.<lambda>>, <TokenType.STAR: 'STAR'>: <function Parser.<lambda>>, <TokenType.NULL: 'NULL'>: <function Parser.<lambda>>, <TokenType.TRUE: 'TRUE'>: <function Parser.<lambda>>, <TokenType.FALSE: 'FALSE'>: <function Parser.<lambda>>, <TokenType.BIT_STRING: 'BIT_STRING'>: <function Parser.<lambda>>, <TokenType.HEX_STRING: 'HEX_STRING'>: <function Parser.<lambda>>, <TokenType.BYTE_STRING: 'BYTE_STRING'>: <function Parser.<lambda>>, <TokenType.INTRODUCER: 'INTRODUCER'>: <function Parser.<lambda>>, <TokenType.NATIONAL_STRING: 'NATIONAL_STRING'>: <function Parser.<lambda>>, <TokenType.RAW_STRING: 'RAW_STRING'>: <function Parser.<lambda>>, <TokenType.HEREDOC_STRING: 'HEREDOC_STRING'>: <function Parser.<lambda>>, <TokenType.UNICODE_STRING: 'UNICODE_STRING'>: <function Parser.<lambda>>, <TokenType.SESSION_PARAMETER: 'SESSION_PARAMETER'>: <function Parser.<lambda>>}
PLACEHOLDER_PARSERS = {<TokenType.PLACEHOLDER: 'PLACEHOLDER'>: <function Parser.<lambda>>, <TokenType.PARAMETER: 'PARAMETER'>: <function Parser.<lambda>>, <TokenType.COLON: 'COLON'>: <function Parser.<lambda>>}
RANGE_PARSERS = {<TokenType.BETWEEN: 'BETWEEN'>: <function Parser.<lambda>>, <TokenType.GLOB: 'GLOB'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.ILIKE: 'ILIKE'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.IN: 'IN'>: <function Parser.<lambda>>, <TokenType.IRLIKE: 'IRLIKE'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.IS: 'IS'>: <function Parser.<lambda>>, <TokenType.LIKE: 'LIKE'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.OVERLAPS: 'OVERLAPS'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.RLIKE: 'RLIKE'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.SIMILAR_TO: 'SIMILAR_TO'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.FOR: 'FOR'>: <function Parser.<lambda>>}
PROPERTY_PARSERS: Dict[str, Callable] = {'ALGORITHM': <function Parser.<lambda>>, 'AUTO': <function Parser.<lambda>>, 'AUTO_INCREMENT': <function Parser.<lambda>>, 'BLOCKCOMPRESSION': <function Parser.<lambda>>, 'CHARSET': <function Parser.<lambda>>, 'CHARACTER SET': <function Parser.<lambda>>, 'CHECKSUM': <function Parser.<lambda>>, 'CLUSTER BY': <function Parser.<lambda>>, 'CLUSTERED': <function Parser.<lambda>>, 'COLLATE': <function Parser.<lambda>>, 'COMMENT': <function Parser.<lambda>>, 'CONTAINS': <function Parser.<lambda>>, 'COPY': <function Parser.<lambda>>, 'DATABLOCKSIZE': <function Parser.<lambda>>, 'DEFINER': <function Parser.<lambda>>, 'DETERMINISTIC': <function Parser.<lambda>>, 'DISTKEY': <function Parser.<lambda>>, 'DISTSTYLE': <function Parser.<lambda>>, 'ENGINE': <function Parser.<lambda>>, 'EXECUTE': <function Parser.<lambda>>, 'EXTERNAL': <function Parser.<lambda>>, 'FALLBACK': <function Parser.<lambda>>, 'FORMAT': <function Parser.<lambda>>, 'FREESPACE': <function Parser.<lambda>>, 'HEAP': <function Parser.<lambda>>, 'IMMUTABLE': <function Parser.<lambda>>, 'INHERITS': <function Parser.<lambda>>, 'INPUT': <function Parser.<lambda>>, 'JOURNAL': <function Parser.<lambda>>, 'LANGUAGE': <function Parser.<lambda>>, 'LAYOUT': <function Parser.<lambda>>, 'LIFETIME': <function Parser.<lambda>>, 'LIKE': <function Parser.<lambda>>, 'LOCATION': <function Parser.<lambda>>, 'LOCK': <function Parser.<lambda>>, 'LOCKING': <function Parser.<lambda>>, 'LOG': <function Parser.<lambda>>, 'MATERIALIZED': <function Parser.<lambda>>, 'MERGEBLOCKRATIO': <function Parser.<lambda>>, 'MODIFIES': <function Parser.<lambda>>, 'MULTISET': <function Parser.<lambda>>, 'NO': <function Parser.<lambda>>, 'ON': <function Parser.<lambda>>, 'ORDER BY': <function Parser.<lambda>>, 'OUTPUT': <function Parser.<lambda>>, 'PARTITION': <function Parser.<lambda>>, 'PARTITION BY': <function Parser.<lambda>>, 'PARTITIONED BY': <function Parser.<lambda>>, 'PARTITIONED_BY': <function Parser.<lambda>>, 'PRIMARY KEY': <function Parser.<lambda>>, 'RANGE': <function Parser.<lambda>>, 'READS': <function Parser.<lambda>>, 'REMOTE': <function Parser.<lambda>>, 'RETURNS': <function Parser.<lambda>>, 'ROW': <function Parser.<lambda>>, 'ROW_FORMAT': <function Parser.<lambda>>, 'SAMPLE': <function Parser.<lambda>>, 'SET': <function Parser.<lambda>>, 'SETTINGS': <function Parser.<lambda>>, 'SORTKEY': <function Parser.<lambda>>, 'SOURCE': <function Parser.<lambda>>, 'STABLE': <function Parser.<lambda>>, 'STORED': <function Parser.<lambda>>, 'SYSTEM_VERSIONING': <function Parser.<lambda>>, 'TBLPROPERTIES': <function Parser.<lambda>>, 'TEMP': <function Parser.<lambda>>, 'TEMPORARY': <function Parser.<lambda>>, 'TO': <function Parser.<lambda>>, 'TRANSIENT': <function Parser.<lambda>>, 'TRANSFORM': <function Parser.<lambda>>, 'TTL': <function Parser.<lambda>>, 'USING': <function Parser.<lambda>>, 'VOLATILE': <function Parser.<lambda>>, 'WITH': <function Parser.<lambda>>}
CONSTRAINT_PARSERS = {'AUTOINCREMENT': <function Parser.<lambda>>, 'AUTO_INCREMENT': <function Parser.<lambda>>, 'CASESPECIFIC': <function Parser.<lambda>>, 'CHARACTER SET': <function Parser.<lambda>>, 'CHECK': <function Parser.<lambda>>, 'COLLATE': <function Parser.<lambda>>, 'COMMENT': <function Parser.<lambda>>, 'COMPRESS': <function Parser.<lambda>>, 'CLUSTERED': <function Parser.<lambda>>, 'NONCLUSTERED': <function Parser.<lambda>>, 'DEFAULT': <function Parser.<lambda>>, 'ENCODE': <function Parser.<lambda>>, 'FOREIGN KEY': <function Parser.<lambda>>, 'FORMAT': <function Parser.<lambda>>, 'GENERATED': <function Parser.<lambda>>, 'IDENTITY': <function Parser.<lambda>>, 'INLINE': <function Parser.<lambda>>, 'LIKE': <function Parser.<lambda>>, 'NOT': <function Parser.<lambda>>, 'NULL': <function Parser.<lambda>>, 'ON': <function Parser.<lambda>>, 'PATH': <function Parser.<lambda>>, 'PERIOD': <function Parser.<lambda>>, 'PRIMARY KEY': <function Parser.<lambda>>, 'REFERENCES': <function Parser.<lambda>>, 'TITLE': <function Parser.<lambda>>, 'TTL': <function Parser.<lambda>>, 'UNIQUE': <function Parser.<lambda>>, 'UPPERCASE': <function Parser.<lambda>>, 'WITH': <function Parser.<lambda>>}
ALTER_PARSERS = {'ADD': <function Parser.<lambda>>, 'ALTER': <function Parser.<lambda>>, 'CLUSTER BY': <function Parser.<lambda>>, 'DELETE': <function Parser.<lambda>>, 'DROP': <function Parser.<lambda>>, 'RENAME': <function Parser.<lambda>>}
SCHEMA_UNNAMED_CONSTRAINTS = {'FOREIGN KEY', 'PERIOD', 'PRIMARY KEY', 'UNIQUE', 'LIKE', 'CHECK'}
NO_PAREN_FUNCTION_PARSERS = {'ANY': <function Parser.<lambda>>, 'CASE': <function Parser.<lambda>>, 'IF': <function Parser.<lambda>>, 'NEXT': <function Parser.<lambda>>}
INVALID_FUNC_NAME_TOKENS = {<TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.STRING: 'STRING'>}
FUNCTIONS_WITH_ALIASED_ARGS = {'STRUCT'}
FUNCTION_PARSERS = {'ANY_VALUE': <function Parser.<lambda>>, 'CAST': <function Parser.<lambda>>, 'CONVERT': <function Parser.<lambda>>, 'DECODE': <function Parser.<lambda>>, 'EXTRACT': <function Parser.<lambda>>, 'JSON_OBJECT': <function Parser.<lambda>>, 'JSON_OBJECTAGG': <function Parser.<lambda>>, 'JSON_TABLE': <function Parser.<lambda>>, 'MATCH': <function Parser.<lambda>>, 'OPENJSON': <function Parser.<lambda>>, 'POSITION': <function Parser.<lambda>>, 'PREDICT': <function Parser.<lambda>>, 'SAFE_CAST': <function Parser.<lambda>>, 'STRING_AGG': <function Parser.<lambda>>, 'SUBSTRING': <function Parser.<lambda>>, 'TRIM': <function Parser.<lambda>>, 'TRY_CAST': <function Parser.<lambda>>, 'TRY_CONVERT': <function Parser.<lambda>>}
QUERY_MODIFIER_PARSERS = {<TokenType.MATCH_RECOGNIZE: 'MATCH_RECOGNIZE'>: <function Parser.<lambda>>, <TokenType.WHERE: 'WHERE'>: <function Parser.<lambda>>, <TokenType.GROUP_BY: 'GROUP_BY'>: <function Parser.<lambda>>, <TokenType.HAVING: 'HAVING'>: <function Parser.<lambda>>, <TokenType.QUALIFY: 'QUALIFY'>: <function Parser.<lambda>>, <TokenType.WINDOW: 'WINDOW'>: <function Parser.<lambda>>, <TokenType.ORDER_BY: 'ORDER_BY'>: <function Parser.<lambda>>, <TokenType.LIMIT: 'LIMIT'>: <function Parser.<lambda>>, <TokenType.FETCH: 'FETCH'>: <function Parser.<lambda>>, <TokenType.OFFSET: 'OFFSET'>: <function Parser.<lambda>>, <TokenType.FOR: 'FOR'>: <function Parser.<lambda>>, <TokenType.LOCK: 'LOCK'>: <function Parser.<lambda>>, <TokenType.TABLE_SAMPLE: 'TABLE_SAMPLE'>: <function Parser.<lambda>>, <TokenType.USING: 'USING'>: <function Parser.<lambda>>, <TokenType.CLUSTER_BY: 'CLUSTER_BY'>: <function Parser.<lambda>>, <TokenType.DISTRIBUTE_BY: 'DISTRIBUTE_BY'>: <function Parser.<lambda>>, <TokenType.SORT_BY: 'SORT_BY'>: <function Parser.<lambda>>, <TokenType.CONNECT_BY: 'CONNECT_BY'>: <function Parser.<lambda>>, <TokenType.START_WITH: 'START_WITH'>: <function Parser.<lambda>>}
SET_PARSERS = {'GLOBAL': <function Parser.<lambda>>, 'LOCAL': <function Parser.<lambda>>, 'SESSION': <function Parser.<lambda>>, 'TRANSACTION': <function Parser.<lambda>>}
SHOW_PARSERS: Dict[str, Callable] = {}
TYPE_LITERAL_PARSERS = {<Type.JSON: 'JSON'>: <function Parser.<lambda>>}
MODIFIABLES = (<class 'sqlglot.expressions.Subquery'>, <class 'sqlglot.expressions.Subqueryable'>, <class 'sqlglot.expressions.Table'>)
DDL_SELECT_TOKENS = {<TokenType.WITH: 'WITH'>, <TokenType.L_PAREN: 'L_PAREN'>, <TokenType.SELECT: 'SELECT'>}
PRE_VOLATILE_TOKENS = {<TokenType.UNIQUE: 'UNIQUE'>, <TokenType.CREATE: 'CREATE'>, <TokenType.REPLACE: 'REPLACE'>}
TRANSACTION_KIND = {'EXCLUSIVE', 'DEFERRED', 'IMMEDIATE'}
TRANSACTION_CHARACTERISTICS = {'READ WRITE', 'ISOLATION LEVEL REPEATABLE READ', 'READ ONLY', 'ISOLATION LEVEL READ UNCOMMITTED', 'ISOLATION LEVEL SERIALIZABLE', 'ISOLATION LEVEL READ COMMITTED'}
INSERT_ALTERNATIVES = {'FAIL', 'ABORT', 'IGNORE', 'ROLLBACK', 'REPLACE'}
CLONE_KEYWORDS = {'CLONE', 'COPY'}
HISTORICAL_DATA_KIND = {'OFFSET', 'TIMESTAMP', 'STREAM', 'STATEMENT'}
OPCLASS_FOLLOW_KEYWORDS = {'ASC', 'NULLS', 'DESC'}
OPTYPE_FOLLOW_TOKENS = {<TokenType.COMMA: 'COMMA'>, <TokenType.R_PAREN: 'R_PAREN'>}
TABLE_INDEX_HINT_TOKENS = {<TokenType.IGNORE: 'IGNORE'>, <TokenType.USE: 'USE'>, <TokenType.FORCE: 'FORCE'>}
WINDOW_ALIAS_TOKENS = {<TokenType.NULL: 'NULL'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.XML: 'XML'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.END: 'END'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.LOAD: 'LOAD'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.LEFT: 'LEFT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.IPV4: 'IPV4'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.SEMI: 'SEMI'>, <TokenType.INT128: 'INT128'>, <TokenType.SHOW: 'SHOW'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.FALSE: 'FALSE'>, <TokenType.MODEL: 'MODEL'>, <TokenType.ANTI: 'ANTI'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.MAP: 'MAP'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.TABLE: 'TABLE'>, <TokenType.TEXT: 'TEXT'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.BINARY: 'BINARY'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.SET: 'SET'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.NATURAL: 'NATURAL'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.NEXT: 'NEXT'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.FILTER: 'FILTER'>, <TokenType.TIME: 'TIME'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.UINT256: 'UINT256'>, <TokenType.DATE32: 'DATE32'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.INET: 'INET'>, <TokenType.APPLY: 'APPLY'>, <TokenType.DESC: 'DESC'>, <TokenType.NESTED: 'NESTED'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.ALL: 'ALL'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.RANGE: 'RANGE'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.IPV6: 'IPV6'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.KEEP: 'KEEP'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.DELETE: 'DELETE'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.ROW: 'ROW'>, <TokenType.MONEY: 'MONEY'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.BIT: 'BIT'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.DATE: 'DATE'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.VAR: 'VAR'>, <TokenType.SUPER: 'SUPER'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.INT256: 'INT256'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.TRUE: 'TRUE'>, <TokenType.SOME: 'SOME'>, <TokenType.UINT: 'UINT'>, <TokenType.UINT128: 'UINT128'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.CASE: 'CASE'>, <TokenType.IS: 'IS'>, <TokenType.INT: 'INT'>, <TokenType.FULL: 'FULL'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.MERGE: 'MERGE'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.FINAL: 'FINAL'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.JSON: 'JSON'>, <TokenType.JSONB: 'JSONB'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.INDEX: 'INDEX'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.USE: 'USE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.ASC: 'ASC'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.KILL: 'KILL'>, <TokenType.CACHE: 'CACHE'>, <TokenType.ANY: 'ANY'>, <TokenType.YEAR: 'YEAR'>, <TokenType.VIEW: 'VIEW'>, <TokenType.FIRST: 'FIRST'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.DIV: 'DIV'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ENUM: 'ENUM'>, <TokenType.TOP: 'TOP'>, <TokenType.CHAR: 'CHAR'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.FUNCTION: 'FUNCTION'>}
WINDOW_BEFORE_PAREN_TOKENS = {<TokenType.OVER: 'OVER'>}
WINDOW_SIDES = {'FOLLOWING', 'PRECEDING'}
JSON_KEY_VALUE_SEPARATOR_TOKENS = {<TokenType.COMMA: 'COMMA'>, <TokenType.IS: 'IS'>, <TokenType.COLON: 'COLON'>}
FETCH_TOKENS = {<TokenType.NULL: 'NULL'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.XML: 'XML'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.END: 'END'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.LOAD: 'LOAD'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.LEFT: 'LEFT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.IPV4: 'IPV4'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.SEMI: 'SEMI'>, <TokenType.INT128: 'INT128'>, <TokenType.SHOW: 'SHOW'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.FALSE: 'FALSE'>, <TokenType.MODEL: 'MODEL'>, <TokenType.ANTI: 'ANTI'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.MAP: 'MAP'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.TABLE: 'TABLE'>, <TokenType.TEXT: 'TEXT'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.BINARY: 'BINARY'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.SET: 'SET'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.NATURAL: 'NATURAL'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.NEXT: 'NEXT'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.FILTER: 'FILTER'>, <TokenType.TIME: 'TIME'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.UINT256: 'UINT256'>, <TokenType.DATE32: 'DATE32'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.INET: 'INET'>, <TokenType.APPLY: 'APPLY'>, <TokenType.DESC: 'DESC'>, <TokenType.NESTED: 'NESTED'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.ALL: 'ALL'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.RANGE: 'RANGE'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.IPV6: 'IPV6'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.KEEP: 'KEEP'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.DELETE: 'DELETE'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.MONEY: 'MONEY'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.BIT: 'BIT'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.DATE: 'DATE'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.VAR: 'VAR'>, <TokenType.SUPER: 'SUPER'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.INT256: 'INT256'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.TRUE: 'TRUE'>, <TokenType.SOME: 'SOME'>, <TokenType.UINT: 'UINT'>, <TokenType.UINT128: 'UINT128'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.CASE: 'CASE'>, <TokenType.IS: 'IS'>, <TokenType.INT: 'INT'>, <TokenType.FULL: 'FULL'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.MERGE: 'MERGE'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.FINAL: 'FINAL'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.JSON: 'JSON'>, <TokenType.JSONB: 'JSONB'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.INDEX: 'INDEX'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.USE: 'USE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.ASC: 'ASC'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.KILL: 'KILL'>, <TokenType.CACHE: 'CACHE'>, <TokenType.ANY: 'ANY'>, <TokenType.YEAR: 'YEAR'>, <TokenType.VIEW: 'VIEW'>, <TokenType.FIRST: 'FIRST'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.DIV: 'DIV'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ENUM: 'ENUM'>, <TokenType.TOP: 'TOP'>, <TokenType.CHAR: 'CHAR'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.FUNCTION: 'FUNCTION'>}
ADD_CONSTRAINT_TOKENS = {<TokenType.PRIMARY_KEY: 'PRIMARY_KEY'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>}
DISTINCT_TOKENS = {<TokenType.DISTINCT: 'DISTINCT'>}
NULL_TOKENS = {<TokenType.NULL: 'NULL'>}
UNNEST_OFFSET_ALIAS_TOKENS = {<TokenType.NULL: 'NULL'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.XML: 'XML'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.END: 'END'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.LOAD: 'LOAD'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.LEFT: 'LEFT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.IPV4: 'IPV4'>, <TokenType.ROWS: 'ROWS'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.SEMI: 'SEMI'>, <TokenType.INT128: 'INT128'>, <TokenType.SHOW: 'SHOW'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.FALSE: 'FALSE'>, <TokenType.MODEL: 'MODEL'>, <TokenType.ANTI: 'ANTI'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.MAP: 'MAP'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.TABLE: 'TABLE'>, <TokenType.TEXT: 'TEXT'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.BINARY: 'BINARY'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.SET: 'SET'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.NATURAL: 'NATURAL'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.NEXT: 'NEXT'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.FILTER: 'FILTER'>, <TokenType.TIME: 'TIME'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.UINT256: 'UINT256'>, <TokenType.DATE32: 'DATE32'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.INET: 'INET'>, <TokenType.APPLY: 'APPLY'>, <TokenType.DESC: 'DESC'>, <TokenType.NESTED: 'NESTED'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.ALL: 'ALL'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.RANGE: 'RANGE'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.IPV6: 'IPV6'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.KEEP: 'KEEP'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.DELETE: 'DELETE'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.ROW: 'ROW'>, <TokenType.MONEY: 'MONEY'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.BIT: 'BIT'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.DATE: 'DATE'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.VAR: 'VAR'>, <TokenType.SUPER: 'SUPER'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.INT256: 'INT256'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.TRUE: 'TRUE'>, <TokenType.SOME: 'SOME'>, <TokenType.UINT: 'UINT'>, <TokenType.UINT128: 'UINT128'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.CASE: 'CASE'>, <TokenType.IS: 'IS'>, <TokenType.INT: 'INT'>, <TokenType.FULL: 'FULL'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.MERGE: 'MERGE'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.FINAL: 'FINAL'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.JSON: 'JSON'>, <TokenType.JSONB: 'JSONB'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.INDEX: 'INDEX'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.USE: 'USE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.ASC: 'ASC'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.KILL: 'KILL'>, <TokenType.CACHE: 'CACHE'>, <TokenType.ANY: 'ANY'>, <TokenType.YEAR: 'YEAR'>, <TokenType.VIEW: 'VIEW'>, <TokenType.FIRST: 'FIRST'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.DIV: 'DIV'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ENUM: 'ENUM'>, <TokenType.TOP: 'TOP'>, <TokenType.CHAR: 'CHAR'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.FUNCTION: 'FUNCTION'>}
STRICT_CAST = True
PREFIXED_PIVOT_COLUMNS = False
IDENTIFY_PIVOT_STRINGS = False
LOG_DEFAULTS_TO_LN = False
ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN = True
TABLESAMPLE_CSV = False
SET_REQUIRES_ASSIGNMENT_DELIMITER = True
TRIM_PATTERN_FIRST = False
STRING_ALIASES = False
MODIFIERS_ATTACHED_TO_UNION = True
UNION_MODIFIERS = {'limit', 'offset', 'order'}
NO_PAREN_IF_COMMANDS = True
SHOW_TRIE: Dict = {}
SET_TRIE: Dict = {'GLOBAL': {0: True}, 'LOCAL': {0: True}, 'SESSION': {0: True}, 'TRANSACTION': {0: True}}
error_level
error_message_context
max_errors
dialect
def reset(self): View Source

    1042    def reset(self):
    1043        self.sql = ""
    1044        self.errors = []
    1045        self._tokens = []
    1046        self._index = 0
    1047        self._curr = None
    1048        self._next = None
    1049        self._prev = None
    1050        self._prev_comments = None

def parse( self, raw_tokens: List[sqlglot.tokens.Token], sql: Optional[str] = None) -> List[Optional[sqlglot.expressions.Expression]]: View Source

    1052    def parse(
    1053        self, raw_tokens: t.List[Token], sql: t.Optional[str] = None
    1054    ) -> t.List[t.Optional[exp.Expression]]:
    1055        """
    1056        Parses a list of tokens and returns a list of syntax trees, one tree
    1057        per parsed SQL statement.
    1058
    1059        Args:
    1060            raw_tokens: The list of tokens.
    1061            sql: The original SQL string, used to produce helpful debug messages.
    1062
    1063        Returns:
    1064            The list of the produced syntax trees.
    1065        """
    1066        return self._parse(
    1067            parse_method=self.__class__._parse_statement, raw_tokens=raw_tokens, sql=sql
    1068        )

Parses a list of tokens and returns a list of syntax trees, one tree per parsed SQL statement.

###### Arguments:

- raw_tokens: The list of tokens.
- sql: The original SQL string, used to produce helpful debug messages.

###### Returns:

> The list of the produced syntax trees.

def parse_into( self, expression_types: Union[str, Type[sqlglot.expressions.Expression], Collection[Union[str, Type[sqlglot.expressions.Expression]]]], raw_tokens: List[sqlglot.tokens.Token], sql: Optional[str] = None) -> List[Optional[sqlglot.expressions.Expression]]: View Source

    1070    def parse_into(
    1071        self,
    1072        expression_types: exp.IntoType,
    1073        raw_tokens: t.List[Token],
    1074        sql: t.Optional[str] = None,
    1075    ) -> t.List[t.Optional[exp.Expression]]:
    1076        """
    1077        Parses a list of tokens into a given Expression type. If a collection of Expression
    1078        types is given instead, this method will try to parse the token list into each one
    1079        of them, stopping at the first for which the parsing succeeds.
    1080
    1081        Args:
    1082            expression_types: The expression type(s) to try and parse the token list into.
    1083            raw_tokens: The list of tokens.
    1084            sql: The original SQL string, used to produce helpful debug messages.
    1085
    1086        Returns:
    1087            The target Expression.
    1088        """
    1089        errors = []
    1090        for expression_type in ensure_list(expression_types):
    1091            parser = self.EXPRESSION_PARSERS.get(expression_type)
    1092            if not parser:
    1093                raise TypeError(f"No parser registered for {expression_type}")
    1094
    1095            try:
    1096                return self._parse(parser, raw_tokens, sql)
    1097            except ParseError as e:
    1098                e.errors[0]["into_expression"] = expression_type
    1099                errors.append(e)
    1100
    1101        raise ParseError(
    1102            f"Failed to parse '{sql or raw_tokens}' into {expression_types}",
    1103            errors=merge_errors(errors),
    1104        ) from errors[-1]

Parses a list of tokens into a given Expression type. If a collection of Expression types is given instead, this method will try to parse the token list into each one of them, stopping at the first for which the parsing succeeds.

###### Arguments:

- expression_types: The expression type(s) to try and parse the token list into.
- raw_tokens: The list of tokens.
- sql: The original SQL string, used to produce helpful debug messages.

###### Returns:

> The target Expression.

def check_errors(self) -> None: View Source

    1141    def check_errors(self) -> None:
    1142        """Logs or raises any found errors, depending on the chosen error level setting."""
    1143        if self.error_level == ErrorLevel.WARN:
    1144            for error in self.errors:
    1145                logger.error(str(error))
    1146        elif self.error_level == ErrorLevel.RAISE and self.errors:
    1147            raise ParseError(
    1148                concat_messages(self.errors, self.max_errors),
    1149                errors=merge_errors(self.errors),
    1150            )

Logs or raises any found errors, depending on the chosen error level setting.

def raise_error(self, message: str, token: Optional[sqlglot.tokens.Token] = None) -> None: View Source

    1152    def raise_error(self, message: str, token: t.Optional[Token] = None) -> None:
    1153        """
    1154        Appends an error in the list of recorded errors or raises it, depending on the chosen
    1155        error level setting.
    1156        """
    1157        token = token or self._curr or self._prev or Token.string("")
    1158        start = token.start
    1159        end = token.end + 1
    1160        start_context = self.sql[max(start - self.error_message_context, 0) : start]
    1161        highlight = self.sql[start:end]
    1162        end_context = self.sql[end : end + self.error_message_context]
    1163
    1164        error = ParseError.new(
    1165            f"{message}. Line {token.line}, Col: {token.col}.\n"
    1166            f"  {start_context}\033[4m{highlight}\033[0m{end_context}",
    1167            description=message,
    1168            line=token.line,
    1169            col=token.col,
    1170            start_context=start_context,
    1171            highlight=highlight,
    1172            end_context=end_context,
    1173        )
    1174
    1175        if self.error_level == ErrorLevel.IMMEDIATE:
    1176            raise error
    1177
    1178        self.errors.append(error)

Appends an error in the list of recorded errors or raises it, depending on the chosen error level setting.

def expression( self, exp_class: Type[~E], comments: Optional[List[str]] = None, **kwargs) -> ~E: View Source

    1180    def expression(
    1181        self, exp_class: t.Type[E], comments: t.Optional[t.List[str]] = None, **kwargs
    1182    ) -> E:
    1183        """
    1184        Creates a new, validated Expression.
    1185
    1186        Args:
    1187            exp_class: The expression class to instantiate.
    1188            comments: An optional list of comments to attach to the expression.
    1189            kwargs: The arguments to set for the expression along with their respective values.
    1190
    1191        Returns:
    1192            The target expression.
    1193        """
    1194        instance = exp_class(**kwargs)
    1195        instance.add_comments(comments) if comments else self._add_comments(instance)
    1196        return self.validate_expression(instance)

Creates a new, validated Expression.

###### Arguments:

- exp_class: The expression class to instantiate.
- comments: An optional list of comments to attach to the expression.
- kwargs: The arguments to set for the expression along with their respective values.

###### Returns:

> The target expression.

def validate_expression(self, expression: ~E, args: Optional[List] = None) -> ~E: View Source

    1203    def validate_expression(self, expression: E, args: t.Optional[t.List] = None) -> E:
    1204        """
    1205        Validates an Expression, making sure that all its mandatory arguments are set.
    1206
    1207        Args:
    1208            expression: The expression to validate.
    1209            args: An optional list of items that was used to instantiate the expression, if it's a Func.
    1210
    1211        Returns:
    1212            The validated expression.
    1213        """
    1214        if self.error_level != ErrorLevel.IGNORE:
    1215            for error_message in expression.error_messages(args):
    1216                self.raise_error(error_message)
    1217
    1218        return expression

Validates an Expression, making sure that all its mandatory arguments are set.

###### Arguments:

- expression: The expression to validate.
- args: An optional list of items that was used to instantiate the expression, if it's a Func.

###### Returns:

> The validated expression.

errors
sql