sqlglot.parser

   1from __future__ import annotations
   2
   3import logging
   4import typing as t
   5import itertools
   6from collections import defaultdict
   7
   8from sqlglot import exp
   9from sqlglot.errors import ErrorLevel, ParseError, concat_messages, merge_errors
  10from sqlglot.helper import apply_index_offset, ensure_list, seq_get
  11from sqlglot.time import format_time
  12from sqlglot.tokens import Token, Tokenizer, TokenType
  13from sqlglot.trie import TrieResult, in_trie, new_trie
  14
  15if t.TYPE_CHECKING:
  16    from sqlglot._typing import E, Lit
  17    from sqlglot.dialects.dialect import Dialect, DialectType
  18
  19    T = t.TypeVar("T")
  20    TCeilFloor = t.TypeVar("TCeilFloor", exp.Ceil, exp.Floor)
  21
  22logger = logging.getLogger("sqlglot")
  23
  24OPTIONS_TYPE = t.Dict[str, t.Sequence[t.Union[t.Sequence[str], str]]]
  25
  26
  27def build_var_map(args: t.List) -> exp.StarMap | exp.VarMap:
  28    if len(args) == 1 and args[0].is_star:
  29        return exp.StarMap(this=args[0])
  30
  31    keys = []
  32    values = []
  33    for i in range(0, len(args), 2):
  34        keys.append(args[i])
  35        values.append(args[i + 1])
  36
  37    return exp.VarMap(keys=exp.array(*keys, copy=False), values=exp.array(*values, copy=False))
  38
  39
  40def build_like(args: t.List) -> exp.Escape | exp.Like:
  41    like = exp.Like(this=seq_get(args, 1), expression=seq_get(args, 0))
  42    return exp.Escape(this=like, expression=seq_get(args, 2)) if len(args) > 2 else like
  43
  44
  45def binary_range_parser(
  46    expr_type: t.Type[exp.Expression], reverse_args: bool = False
  47) -> t.Callable[[Parser, t.Optional[exp.Expression]], t.Optional[exp.Expression]]:
  48    def _parse_binary_range(
  49        self: Parser, this: t.Optional[exp.Expression]
  50    ) -> t.Optional[exp.Expression]:
  51        expression = self._parse_bitwise()
  52        if reverse_args:
  53            this, expression = expression, this
  54        return self._parse_escape(self.expression(expr_type, this=this, expression=expression))
  55
  56    return _parse_binary_range
  57
  58
  59def build_logarithm(args: t.List, dialect: Dialect) -> exp.Func:
  60    # Default argument order is base, expression
  61    this = seq_get(args, 0)
  62    expression = seq_get(args, 1)
  63
  64    if expression:
  65        if not dialect.LOG_BASE_FIRST:
  66            this, expression = expression, this
  67        return exp.Log(this=this, expression=expression)
  68
  69    return (exp.Ln if dialect.parser_class.LOG_DEFAULTS_TO_LN else exp.Log)(this=this)
  70
  71
  72def build_hex(args: t.List, dialect: Dialect) -> exp.Hex | exp.LowerHex:
  73    arg = seq_get(args, 0)
  74    return exp.LowerHex(this=arg) if dialect.HEX_LOWERCASE else exp.Hex(this=arg)
  75
  76
  77def build_lower(args: t.List) -> exp.Lower | exp.Hex:
  78    # LOWER(HEX(..)) can be simplified to LowerHex to simplify its transpilation
  79    arg = seq_get(args, 0)
  80    return exp.LowerHex(this=arg.this) if isinstance(arg, exp.Hex) else exp.Lower(this=arg)
  81
  82
  83def build_upper(args: t.List) -> exp.Upper | exp.Hex:
  84    # UPPER(HEX(..)) can be simplified to Hex to simplify its transpilation
  85    arg = seq_get(args, 0)
  86    return exp.Hex(this=arg.this) if isinstance(arg, exp.Hex) else exp.Upper(this=arg)
  87
  88
  89def build_extract_json_with_path(expr_type: t.Type[E]) -> t.Callable[[t.List, Dialect], E]:
  90    def _builder(args: t.List, dialect: Dialect) -> E:
  91        expression = expr_type(
  92            this=seq_get(args, 0), expression=dialect.to_json_path(seq_get(args, 1))
  93        )
  94        if len(args) > 2 and expr_type is exp.JSONExtract:
  95            expression.set("expressions", args[2:])
  96
  97        return expression
  98
  99    return _builder
 100
 101
 102def build_mod(args: t.List) -> exp.Mod:
 103    this = seq_get(args, 0)
 104    expression = seq_get(args, 1)
 105
 106    # Wrap the operands if they are binary nodes, e.g. MOD(a + 1, 7) -> (a + 1) % 7
 107    this = exp.Paren(this=this) if isinstance(this, exp.Binary) else this
 108    expression = exp.Paren(this=expression) if isinstance(expression, exp.Binary) else expression
 109
 110    return exp.Mod(this=this, expression=expression)
 111
 112
 113def build_pad(args: t.List, is_left: bool = True):
 114    return exp.Pad(
 115        this=seq_get(args, 0),
 116        expression=seq_get(args, 1),
 117        fill_pattern=seq_get(args, 2),
 118        is_left=is_left,
 119    )
 120
 121
 122def build_array_constructor(
 123    exp_class: t.Type[E], args: t.List, bracket_kind: TokenType, dialect: Dialect
 124) -> exp.Expression:
 125    array_exp = exp_class(expressions=args)
 126
 127    if exp_class == exp.Array and dialect.HAS_DISTINCT_ARRAY_CONSTRUCTORS:
 128        array_exp.set("bracket_notation", bracket_kind == TokenType.L_BRACKET)
 129
 130    return array_exp
 131
 132
 133def build_convert_timezone(
 134    args: t.List, default_source_tz: t.Optional[str] = None
 135) -> t.Union[exp.ConvertTimezone, exp.Anonymous]:
 136    if len(args) == 2:
 137        source_tz = exp.Literal.string(default_source_tz) if default_source_tz else None
 138        return exp.ConvertTimezone(
 139            source_tz=source_tz, target_tz=seq_get(args, 0), timestamp=seq_get(args, 1)
 140        )
 141
 142    return exp.ConvertTimezone.from_arg_list(args)
 143
 144
 145def build_trim(args: t.List, is_left: bool = True):
 146    return exp.Trim(
 147        this=seq_get(args, 0),
 148        expression=seq_get(args, 1),
 149        position="LEADING" if is_left else "TRAILING",
 150    )
 151
 152
 153def build_coalesce(args: t.List, is_nvl: t.Optional[bool] = None) -> exp.Coalesce:
 154    return exp.Coalesce(this=seq_get(args, 0), expressions=args[1:], is_nvl=is_nvl)
 155
 156
 157def build_locate_strposition(args: t.List):
 158    return exp.StrPosition(
 159        this=seq_get(args, 1),
 160        substr=seq_get(args, 0),
 161        position=seq_get(args, 2),
 162    )
 163
 164
 165class _Parser(type):
 166    def __new__(cls, clsname, bases, attrs):
 167        klass = super().__new__(cls, clsname, bases, attrs)
 168
 169        klass.SHOW_TRIE = new_trie(key.split(" ") for key in klass.SHOW_PARSERS)
 170        klass.SET_TRIE = new_trie(key.split(" ") for key in klass.SET_PARSERS)
 171
 172        return klass
 173
 174
 175class Parser(metaclass=_Parser):
 176    """
 177    Parser consumes a list of tokens produced by the Tokenizer and produces a parsed syntax tree.
 178
 179    Args:
 180        error_level: The desired error level.
 181            Default: ErrorLevel.IMMEDIATE
 182        error_message_context: The amount of context to capture from a query string when displaying
 183            the error message (in number of characters).
 184            Default: 100
 185        max_errors: Maximum number of error messages to include in a raised ParseError.
 186            This is only relevant if error_level is ErrorLevel.RAISE.
 187            Default: 3
 188    """
 189
 190    FUNCTIONS: t.Dict[str, t.Callable] = {
 191        **{name: func.from_arg_list for name, func in exp.FUNCTION_BY_NAME.items()},
 192        **dict.fromkeys(("COALESCE", "IFNULL", "NVL"), build_coalesce),
 193        "ARRAY": lambda args, dialect: exp.Array(expressions=args),
 194        "ARRAYAGG": lambda args, dialect: exp.ArrayAgg(
 195            this=seq_get(args, 0), nulls_excluded=dialect.ARRAY_AGG_INCLUDES_NULLS is None or None
 196        ),
 197        "ARRAY_AGG": lambda args, dialect: exp.ArrayAgg(
 198            this=seq_get(args, 0), nulls_excluded=dialect.ARRAY_AGG_INCLUDES_NULLS is None or None
 199        ),
 200        "CHAR": lambda args: exp.Chr(expressions=args),
 201        "CHR": lambda args: exp.Chr(expressions=args),
 202        "COUNT": lambda args: exp.Count(this=seq_get(args, 0), expressions=args[1:], big_int=True),
 203        "CONCAT": lambda args, dialect: exp.Concat(
 204            expressions=args,
 205            safe=not dialect.STRICT_STRING_CONCAT,
 206            coalesce=dialect.CONCAT_COALESCE,
 207        ),
 208        "CONCAT_WS": lambda args, dialect: exp.ConcatWs(
 209            expressions=args,
 210            safe=not dialect.STRICT_STRING_CONCAT,
 211            coalesce=dialect.CONCAT_COALESCE,
 212        ),
 213        "CONVERT_TIMEZONE": build_convert_timezone,
 214        "DATE_TO_DATE_STR": lambda args: exp.Cast(
 215            this=seq_get(args, 0),
 216            to=exp.DataType(this=exp.DataType.Type.TEXT),
 217        ),
 218        "GENERATE_DATE_ARRAY": lambda args: exp.GenerateDateArray(
 219            start=seq_get(args, 0),
 220            end=seq_get(args, 1),
 221            step=seq_get(args, 2) or exp.Interval(this=exp.Literal.string(1), unit=exp.var("DAY")),
 222        ),
 223        "GLOB": lambda args: exp.Glob(this=seq_get(args, 1), expression=seq_get(args, 0)),
 224        "HEX": build_hex,
 225        "JSON_EXTRACT": build_extract_json_with_path(exp.JSONExtract),
 226        "JSON_EXTRACT_SCALAR": build_extract_json_with_path(exp.JSONExtractScalar),
 227        "JSON_EXTRACT_PATH_TEXT": build_extract_json_with_path(exp.JSONExtractScalar),
 228        "LIKE": build_like,
 229        "LOG": build_logarithm,
 230        "LOG2": lambda args: exp.Log(this=exp.Literal.number(2), expression=seq_get(args, 0)),
 231        "LOG10": lambda args: exp.Log(this=exp.Literal.number(10), expression=seq_get(args, 0)),
 232        "LOWER": build_lower,
 233        "LPAD": lambda args: build_pad(args),
 234        "LEFTPAD": lambda args: build_pad(args),
 235        "LTRIM": lambda args: build_trim(args),
 236        "MOD": build_mod,
 237        "RIGHTPAD": lambda args: build_pad(args, is_left=False),
 238        "RPAD": lambda args: build_pad(args, is_left=False),
 239        "RTRIM": lambda args: build_trim(args, is_left=False),
 240        "SCOPE_RESOLUTION": lambda args: exp.ScopeResolution(expression=seq_get(args, 0))
 241        if len(args) != 2
 242        else exp.ScopeResolution(this=seq_get(args, 0), expression=seq_get(args, 1)),
 243        "STRPOS": exp.StrPosition.from_arg_list,
 244        "CHARINDEX": lambda args: build_locate_strposition(args),
 245        "INSTR": exp.StrPosition.from_arg_list,
 246        "LOCATE": lambda args: build_locate_strposition(args),
 247        "TIME_TO_TIME_STR": lambda args: exp.Cast(
 248            this=seq_get(args, 0),
 249            to=exp.DataType(this=exp.DataType.Type.TEXT),
 250        ),
 251        "TO_HEX": build_hex,
 252        "TS_OR_DS_TO_DATE_STR": lambda args: exp.Substring(
 253            this=exp.Cast(
 254                this=seq_get(args, 0),
 255                to=exp.DataType(this=exp.DataType.Type.TEXT),
 256            ),
 257            start=exp.Literal.number(1),
 258            length=exp.Literal.number(10),
 259        ),
 260        "UNNEST": lambda args: exp.Unnest(expressions=ensure_list(seq_get(args, 0))),
 261        "UPPER": build_upper,
 262        "VAR_MAP": build_var_map,
 263    }
 264
 265    NO_PAREN_FUNCTIONS = {
 266        TokenType.CURRENT_DATE: exp.CurrentDate,
 267        TokenType.CURRENT_DATETIME: exp.CurrentDate,
 268        TokenType.CURRENT_TIME: exp.CurrentTime,
 269        TokenType.CURRENT_TIMESTAMP: exp.CurrentTimestamp,
 270        TokenType.CURRENT_USER: exp.CurrentUser,
 271    }
 272
 273    STRUCT_TYPE_TOKENS = {
 274        TokenType.NESTED,
 275        TokenType.OBJECT,
 276        TokenType.STRUCT,
 277        TokenType.UNION,
 278    }
 279
 280    NESTED_TYPE_TOKENS = {
 281        TokenType.ARRAY,
 282        TokenType.LIST,
 283        TokenType.LOWCARDINALITY,
 284        TokenType.MAP,
 285        TokenType.NULLABLE,
 286        TokenType.RANGE,
 287        *STRUCT_TYPE_TOKENS,
 288    }
 289
 290    ENUM_TYPE_TOKENS = {
 291        TokenType.DYNAMIC,
 292        TokenType.ENUM,
 293        TokenType.ENUM8,
 294        TokenType.ENUM16,
 295    }
 296
 297    AGGREGATE_TYPE_TOKENS = {
 298        TokenType.AGGREGATEFUNCTION,
 299        TokenType.SIMPLEAGGREGATEFUNCTION,
 300    }
 301
 302    TYPE_TOKENS = {
 303        TokenType.BIT,
 304        TokenType.BOOLEAN,
 305        TokenType.TINYINT,
 306        TokenType.UTINYINT,
 307        TokenType.SMALLINT,
 308        TokenType.USMALLINT,
 309        TokenType.INT,
 310        TokenType.UINT,
 311        TokenType.BIGINT,
 312        TokenType.UBIGINT,
 313        TokenType.INT128,
 314        TokenType.UINT128,
 315        TokenType.INT256,
 316        TokenType.UINT256,
 317        TokenType.MEDIUMINT,
 318        TokenType.UMEDIUMINT,
 319        TokenType.FIXEDSTRING,
 320        TokenType.FLOAT,
 321        TokenType.DOUBLE,
 322        TokenType.UDOUBLE,
 323        TokenType.CHAR,
 324        TokenType.NCHAR,
 325        TokenType.VARCHAR,
 326        TokenType.NVARCHAR,
 327        TokenType.BPCHAR,
 328        TokenType.TEXT,
 329        TokenType.MEDIUMTEXT,
 330        TokenType.LONGTEXT,
 331        TokenType.BLOB,
 332        TokenType.MEDIUMBLOB,
 333        TokenType.LONGBLOB,
 334        TokenType.BINARY,
 335        TokenType.VARBINARY,
 336        TokenType.JSON,
 337        TokenType.JSONB,
 338        TokenType.INTERVAL,
 339        TokenType.TINYBLOB,
 340        TokenType.TINYTEXT,
 341        TokenType.TIME,
 342        TokenType.TIMETZ,
 343        TokenType.TIMESTAMP,
 344        TokenType.TIMESTAMP_S,
 345        TokenType.TIMESTAMP_MS,
 346        TokenType.TIMESTAMP_NS,
 347        TokenType.TIMESTAMPTZ,
 348        TokenType.TIMESTAMPLTZ,
 349        TokenType.TIMESTAMPNTZ,
 350        TokenType.DATETIME,
 351        TokenType.DATETIME2,
 352        TokenType.DATETIME64,
 353        TokenType.SMALLDATETIME,
 354        TokenType.DATE,
 355        TokenType.DATE32,
 356        TokenType.INT4RANGE,
 357        TokenType.INT4MULTIRANGE,
 358        TokenType.INT8RANGE,
 359        TokenType.INT8MULTIRANGE,
 360        TokenType.NUMRANGE,
 361        TokenType.NUMMULTIRANGE,
 362        TokenType.TSRANGE,
 363        TokenType.TSMULTIRANGE,
 364        TokenType.TSTZRANGE,
 365        TokenType.TSTZMULTIRANGE,
 366        TokenType.DATERANGE,
 367        TokenType.DATEMULTIRANGE,
 368        TokenType.DECIMAL,
 369        TokenType.DECIMAL32,
 370        TokenType.DECIMAL64,
 371        TokenType.DECIMAL128,
 372        TokenType.DECIMAL256,
 373        TokenType.UDECIMAL,
 374        TokenType.BIGDECIMAL,
 375        TokenType.UUID,
 376        TokenType.GEOGRAPHY,
 377        TokenType.GEOMETRY,
 378        TokenType.POINT,
 379        TokenType.RING,
 380        TokenType.LINESTRING,
 381        TokenType.MULTILINESTRING,
 382        TokenType.POLYGON,
 383        TokenType.MULTIPOLYGON,
 384        TokenType.HLLSKETCH,
 385        TokenType.HSTORE,
 386        TokenType.PSEUDO_TYPE,
 387        TokenType.SUPER,
 388        TokenType.SERIAL,
 389        TokenType.SMALLSERIAL,
 390        TokenType.BIGSERIAL,
 391        TokenType.XML,
 392        TokenType.YEAR,
 393        TokenType.USERDEFINED,
 394        TokenType.MONEY,
 395        TokenType.SMALLMONEY,
 396        TokenType.ROWVERSION,
 397        TokenType.IMAGE,
 398        TokenType.VARIANT,
 399        TokenType.VECTOR,
 400        TokenType.VOID,
 401        TokenType.OBJECT,
 402        TokenType.OBJECT_IDENTIFIER,
 403        TokenType.INET,
 404        TokenType.IPADDRESS,
 405        TokenType.IPPREFIX,
 406        TokenType.IPV4,
 407        TokenType.IPV6,
 408        TokenType.UNKNOWN,
 409        TokenType.NOTHING,
 410        TokenType.NULL,
 411        TokenType.NAME,
 412        TokenType.TDIGEST,
 413        TokenType.DYNAMIC,
 414        *ENUM_TYPE_TOKENS,
 415        *NESTED_TYPE_TOKENS,
 416        *AGGREGATE_TYPE_TOKENS,
 417    }
 418
 419    SIGNED_TO_UNSIGNED_TYPE_TOKEN = {
 420        TokenType.BIGINT: TokenType.UBIGINT,
 421        TokenType.INT: TokenType.UINT,
 422        TokenType.MEDIUMINT: TokenType.UMEDIUMINT,
 423        TokenType.SMALLINT: TokenType.USMALLINT,
 424        TokenType.TINYINT: TokenType.UTINYINT,
 425        TokenType.DECIMAL: TokenType.UDECIMAL,
 426        TokenType.DOUBLE: TokenType.UDOUBLE,
 427    }
 428
 429    SUBQUERY_PREDICATES = {
 430        TokenType.ANY: exp.Any,
 431        TokenType.ALL: exp.All,
 432        TokenType.EXISTS: exp.Exists,
 433        TokenType.SOME: exp.Any,
 434    }
 435
 436    RESERVED_TOKENS = {
 437        *Tokenizer.SINGLE_TOKENS.values(),
 438        TokenType.SELECT,
 439    } - {TokenType.IDENTIFIER}
 440
 441    DB_CREATABLES = {
 442        TokenType.DATABASE,
 443        TokenType.DICTIONARY,
 444        TokenType.FILE_FORMAT,
 445        TokenType.MODEL,
 446        TokenType.NAMESPACE,
 447        TokenType.SCHEMA,
 448        TokenType.SEQUENCE,
 449        TokenType.SINK,
 450        TokenType.SOURCE,
 451        TokenType.STAGE,
 452        TokenType.STORAGE_INTEGRATION,
 453        TokenType.STREAMLIT,
 454        TokenType.TABLE,
 455        TokenType.TAG,
 456        TokenType.VIEW,
 457        TokenType.WAREHOUSE,
 458    }
 459
 460    CREATABLES = {
 461        TokenType.COLUMN,
 462        TokenType.CONSTRAINT,
 463        TokenType.FOREIGN_KEY,
 464        TokenType.FUNCTION,
 465        TokenType.INDEX,
 466        TokenType.PROCEDURE,
 467        *DB_CREATABLES,
 468    }
 469
 470    ALTERABLES = {
 471        TokenType.INDEX,
 472        TokenType.TABLE,
 473        TokenType.VIEW,
 474    }
 475
 476    # Tokens that can represent identifiers
 477    ID_VAR_TOKENS = {
 478        TokenType.ALL,
 479        TokenType.ATTACH,
 480        TokenType.VAR,
 481        TokenType.ANTI,
 482        TokenType.APPLY,
 483        TokenType.ASC,
 484        TokenType.ASOF,
 485        TokenType.AUTO_INCREMENT,
 486        TokenType.BEGIN,
 487        TokenType.BPCHAR,
 488        TokenType.CACHE,
 489        TokenType.CASE,
 490        TokenType.COLLATE,
 491        TokenType.COMMAND,
 492        TokenType.COMMENT,
 493        TokenType.COMMIT,
 494        TokenType.CONSTRAINT,
 495        TokenType.COPY,
 496        TokenType.CUBE,
 497        TokenType.CURRENT_SCHEMA,
 498        TokenType.DEFAULT,
 499        TokenType.DELETE,
 500        TokenType.DESC,
 501        TokenType.DESCRIBE,
 502        TokenType.DETACH,
 503        TokenType.DICTIONARY,
 504        TokenType.DIV,
 505        TokenType.END,
 506        TokenType.EXECUTE,
 507        TokenType.EXPORT,
 508        TokenType.ESCAPE,
 509        TokenType.FALSE,
 510        TokenType.FIRST,
 511        TokenType.FILTER,
 512        TokenType.FINAL,
 513        TokenType.FORMAT,
 514        TokenType.FULL,
 515        TokenType.GET,
 516        TokenType.IDENTIFIER,
 517        TokenType.IS,
 518        TokenType.ISNULL,
 519        TokenType.INTERVAL,
 520        TokenType.KEEP,
 521        TokenType.KILL,
 522        TokenType.LEFT,
 523        TokenType.LIMIT,
 524        TokenType.LOAD,
 525        TokenType.MERGE,
 526        TokenType.NATURAL,
 527        TokenType.NEXT,
 528        TokenType.OFFSET,
 529        TokenType.OPERATOR,
 530        TokenType.ORDINALITY,
 531        TokenType.OVERLAPS,
 532        TokenType.OVERWRITE,
 533        TokenType.PARTITION,
 534        TokenType.PERCENT,
 535        TokenType.PIVOT,
 536        TokenType.PRAGMA,
 537        TokenType.PUT,
 538        TokenType.RANGE,
 539        TokenType.RECURSIVE,
 540        TokenType.REFERENCES,
 541        TokenType.REFRESH,
 542        TokenType.RENAME,
 543        TokenType.REPLACE,
 544        TokenType.RIGHT,
 545        TokenType.ROLLUP,
 546        TokenType.ROW,
 547        TokenType.ROWS,
 548        TokenType.SEMI,
 549        TokenType.SET,
 550        TokenType.SETTINGS,
 551        TokenType.SHOW,
 552        TokenType.TEMPORARY,
 553        TokenType.TOP,
 554        TokenType.TRUE,
 555        TokenType.TRUNCATE,
 556        TokenType.UNIQUE,
 557        TokenType.UNNEST,
 558        TokenType.UNPIVOT,
 559        TokenType.UPDATE,
 560        TokenType.USE,
 561        TokenType.VOLATILE,
 562        TokenType.WINDOW,
 563        *CREATABLES,
 564        *SUBQUERY_PREDICATES,
 565        *TYPE_TOKENS,
 566        *NO_PAREN_FUNCTIONS,
 567    }
 568    ID_VAR_TOKENS.remove(TokenType.UNION)
 569
 570    TABLE_ALIAS_TOKENS = ID_VAR_TOKENS - {
 571        TokenType.ANTI,
 572        TokenType.APPLY,
 573        TokenType.ASOF,
 574        TokenType.FULL,
 575        TokenType.LEFT,
 576        TokenType.LOCK,
 577        TokenType.NATURAL,
 578        TokenType.RIGHT,
 579        TokenType.SEMI,
 580        TokenType.WINDOW,
 581    }
 582
 583    ALIAS_TOKENS = ID_VAR_TOKENS
 584
 585    COLON_PLACEHOLDER_TOKENS = ID_VAR_TOKENS
 586
 587    ARRAY_CONSTRUCTORS = {
 588        "ARRAY": exp.Array,
 589        "LIST": exp.List,
 590    }
 591
 592    COMMENT_TABLE_ALIAS_TOKENS = TABLE_ALIAS_TOKENS - {TokenType.IS}
 593
 594    UPDATE_ALIAS_TOKENS = TABLE_ALIAS_TOKENS - {TokenType.SET}
 595
 596    TRIM_TYPES = {"LEADING", "TRAILING", "BOTH"}
 597
 598    FUNC_TOKENS = {
 599        TokenType.COLLATE,
 600        TokenType.COMMAND,
 601        TokenType.CURRENT_DATE,
 602        TokenType.CURRENT_DATETIME,
 603        TokenType.CURRENT_SCHEMA,
 604        TokenType.CURRENT_TIMESTAMP,
 605        TokenType.CURRENT_TIME,
 606        TokenType.CURRENT_USER,
 607        TokenType.FILTER,
 608        TokenType.FIRST,
 609        TokenType.FORMAT,
 610        TokenType.GLOB,
 611        TokenType.IDENTIFIER,
 612        TokenType.INDEX,
 613        TokenType.ISNULL,
 614        TokenType.ILIKE,
 615        TokenType.INSERT,
 616        TokenType.LIKE,
 617        TokenType.MERGE,
 618        TokenType.NEXT,
 619        TokenType.OFFSET,
 620        TokenType.PRIMARY_KEY,
 621        TokenType.RANGE,
 622        TokenType.REPLACE,
 623        TokenType.RLIKE,
 624        TokenType.ROW,
 625        TokenType.UNNEST,
 626        TokenType.VAR,
 627        TokenType.LEFT,
 628        TokenType.RIGHT,
 629        TokenType.SEQUENCE,
 630        TokenType.DATE,
 631        TokenType.DATETIME,
 632        TokenType.TABLE,
 633        TokenType.TIMESTAMP,
 634        TokenType.TIMESTAMPTZ,
 635        TokenType.TRUNCATE,
 636        TokenType.WINDOW,
 637        TokenType.XOR,
 638        *TYPE_TOKENS,
 639        *SUBQUERY_PREDICATES,
 640    }
 641
 642    CONJUNCTION: t.Dict[TokenType, t.Type[exp.Expression]] = {
 643        TokenType.AND: exp.And,
 644    }
 645
 646    ASSIGNMENT: t.Dict[TokenType, t.Type[exp.Expression]] = {
 647        TokenType.COLON_EQ: exp.PropertyEQ,
 648    }
 649
 650    DISJUNCTION: t.Dict[TokenType, t.Type[exp.Expression]] = {
 651        TokenType.OR: exp.Or,
 652    }
 653
 654    EQUALITY = {
 655        TokenType.EQ: exp.EQ,
 656        TokenType.NEQ: exp.NEQ,
 657        TokenType.NULLSAFE_EQ: exp.NullSafeEQ,
 658    }
 659
 660    COMPARISON = {
 661        TokenType.GT: exp.GT,
 662        TokenType.GTE: exp.GTE,
 663        TokenType.LT: exp.LT,
 664        TokenType.LTE: exp.LTE,
 665    }
 666
 667    BITWISE = {
 668        TokenType.AMP: exp.BitwiseAnd,
 669        TokenType.CARET: exp.BitwiseXor,
 670        TokenType.PIPE: exp.BitwiseOr,
 671    }
 672
 673    TERM = {
 674        TokenType.DASH: exp.Sub,
 675        TokenType.PLUS: exp.Add,
 676        TokenType.MOD: exp.Mod,
 677        TokenType.COLLATE: exp.Collate,
 678    }
 679
 680    FACTOR = {
 681        TokenType.DIV: exp.IntDiv,
 682        TokenType.LR_ARROW: exp.Distance,
 683        TokenType.SLASH: exp.Div,
 684        TokenType.STAR: exp.Mul,
 685    }
 686
 687    EXPONENT: t.Dict[TokenType, t.Type[exp.Expression]] = {}
 688
 689    TIMES = {
 690        TokenType.TIME,
 691        TokenType.TIMETZ,
 692    }
 693
 694    TIMESTAMPS = {
 695        TokenType.TIMESTAMP,
 696        TokenType.TIMESTAMPNTZ,
 697        TokenType.TIMESTAMPTZ,
 698        TokenType.TIMESTAMPLTZ,
 699        *TIMES,
 700    }
 701
 702    SET_OPERATIONS = {
 703        TokenType.UNION,
 704        TokenType.INTERSECT,
 705        TokenType.EXCEPT,
 706    }
 707
 708    JOIN_METHODS = {
 709        TokenType.ASOF,
 710        TokenType.NATURAL,
 711        TokenType.POSITIONAL,
 712    }
 713
 714    JOIN_SIDES = {
 715        TokenType.LEFT,
 716        TokenType.RIGHT,
 717        TokenType.FULL,
 718    }
 719
 720    JOIN_KINDS = {
 721        TokenType.ANTI,
 722        TokenType.CROSS,
 723        TokenType.INNER,
 724        TokenType.OUTER,
 725        TokenType.SEMI,
 726        TokenType.STRAIGHT_JOIN,
 727    }
 728
 729    JOIN_HINTS: t.Set[str] = set()
 730
 731    LAMBDAS = {
 732        TokenType.ARROW: lambda self, expressions: self.expression(
 733            exp.Lambda,
 734            this=self._replace_lambda(
 735                self._parse_assignment(),
 736                expressions,
 737            ),
 738            expressions=expressions,
 739        ),
 740        TokenType.FARROW: lambda self, expressions: self.expression(
 741            exp.Kwarg,
 742            this=exp.var(expressions[0].name),
 743            expression=self._parse_assignment(),
 744        ),
 745    }
 746
 747    COLUMN_OPERATORS = {
 748        TokenType.DOT: None,
 749        TokenType.DOTCOLON: lambda self, this, to: self.expression(
 750            exp.JSONCast,
 751            this=this,
 752            to=to,
 753        ),
 754        TokenType.DCOLON: lambda self, this, to: self.expression(
 755            exp.Cast if self.STRICT_CAST else exp.TryCast,
 756            this=this,
 757            to=to,
 758        ),
 759        TokenType.ARROW: lambda self, this, path: self.expression(
 760            exp.JSONExtract,
 761            this=this,
 762            expression=self.dialect.to_json_path(path),
 763            only_json_types=self.JSON_ARROWS_REQUIRE_JSON_TYPE,
 764        ),
 765        TokenType.DARROW: lambda self, this, path: self.expression(
 766            exp.JSONExtractScalar,
 767            this=this,
 768            expression=self.dialect.to_json_path(path),
 769            only_json_types=self.JSON_ARROWS_REQUIRE_JSON_TYPE,
 770        ),
 771        TokenType.HASH_ARROW: lambda self, this, path: self.expression(
 772            exp.JSONBExtract,
 773            this=this,
 774            expression=path,
 775        ),
 776        TokenType.DHASH_ARROW: lambda self, this, path: self.expression(
 777            exp.JSONBExtractScalar,
 778            this=this,
 779            expression=path,
 780        ),
 781        TokenType.PLACEHOLDER: lambda self, this, key: self.expression(
 782            exp.JSONBContains,
 783            this=this,
 784            expression=key,
 785        ),
 786    }
 787
 788    EXPRESSION_PARSERS = {
 789        exp.Cluster: lambda self: self._parse_sort(exp.Cluster, TokenType.CLUSTER_BY),
 790        exp.Column: lambda self: self._parse_column(),
 791        exp.Condition: lambda self: self._parse_assignment(),
 792        exp.DataType: lambda self: self._parse_types(allow_identifiers=False, schema=True),
 793        exp.Expression: lambda self: self._parse_expression(),
 794        exp.From: lambda self: self._parse_from(joins=True),
 795        exp.Group: lambda self: self._parse_group(),
 796        exp.Having: lambda self: self._parse_having(),
 797        exp.Hint: lambda self: self._parse_hint_body(),
 798        exp.Identifier: lambda self: self._parse_id_var(),
 799        exp.Join: lambda self: self._parse_join(),
 800        exp.Lambda: lambda self: self._parse_lambda(),
 801        exp.Lateral: lambda self: self._parse_lateral(),
 802        exp.Limit: lambda self: self._parse_limit(),
 803        exp.Offset: lambda self: self._parse_offset(),
 804        exp.Order: lambda self: self._parse_order(),
 805        exp.Ordered: lambda self: self._parse_ordered(),
 806        exp.Properties: lambda self: self._parse_properties(),
 807        exp.PartitionedByProperty: lambda self: self._parse_partitioned_by(),
 808        exp.Qualify: lambda self: self._parse_qualify(),
 809        exp.Returning: lambda self: self._parse_returning(),
 810        exp.Select: lambda self: self._parse_select(),
 811        exp.Sort: lambda self: self._parse_sort(exp.Sort, TokenType.SORT_BY),
 812        exp.Table: lambda self: self._parse_table_parts(),
 813        exp.TableAlias: lambda self: self._parse_table_alias(),
 814        exp.Tuple: lambda self: self._parse_value(values=False),
 815        exp.Whens: lambda self: self._parse_when_matched(),
 816        exp.Where: lambda self: self._parse_where(),
 817        exp.Window: lambda self: self._parse_named_window(),
 818        exp.With: lambda self: self._parse_with(),
 819        "JOIN_TYPE": lambda self: self._parse_join_parts(),
 820    }
 821
 822    STATEMENT_PARSERS = {
 823        TokenType.ALTER: lambda self: self._parse_alter(),
 824        TokenType.ANALYZE: lambda self: self._parse_analyze(),
 825        TokenType.BEGIN: lambda self: self._parse_transaction(),
 826        TokenType.CACHE: lambda self: self._parse_cache(),
 827        TokenType.COMMENT: lambda self: self._parse_comment(),
 828        TokenType.COMMIT: lambda self: self._parse_commit_or_rollback(),
 829        TokenType.COPY: lambda self: self._parse_copy(),
 830        TokenType.CREATE: lambda self: self._parse_create(),
 831        TokenType.DELETE: lambda self: self._parse_delete(),
 832        TokenType.DESC: lambda self: self._parse_describe(),
 833        TokenType.DESCRIBE: lambda self: self._parse_describe(),
 834        TokenType.DROP: lambda self: self._parse_drop(),
 835        TokenType.GRANT: lambda self: self._parse_grant(),
 836        TokenType.INSERT: lambda self: self._parse_insert(),
 837        TokenType.KILL: lambda self: self._parse_kill(),
 838        TokenType.LOAD: lambda self: self._parse_load(),
 839        TokenType.MERGE: lambda self: self._parse_merge(),
 840        TokenType.PIVOT: lambda self: self._parse_simplified_pivot(),
 841        TokenType.PRAGMA: lambda self: self.expression(exp.Pragma, this=self._parse_expression()),
 842        TokenType.REFRESH: lambda self: self._parse_refresh(),
 843        TokenType.ROLLBACK: lambda self: self._parse_commit_or_rollback(),
 844        TokenType.SET: lambda self: self._parse_set(),
 845        TokenType.TRUNCATE: lambda self: self._parse_truncate_table(),
 846        TokenType.UNCACHE: lambda self: self._parse_uncache(),
 847        TokenType.UNPIVOT: lambda self: self._parse_simplified_pivot(is_unpivot=True),
 848        TokenType.UPDATE: lambda self: self._parse_update(),
 849        TokenType.USE: lambda self: self._parse_use(),
 850        TokenType.SEMICOLON: lambda self: exp.Semicolon(),
 851    }
 852
 853    UNARY_PARSERS = {
 854        TokenType.PLUS: lambda self: self._parse_unary(),  # Unary + is handled as a no-op
 855        TokenType.NOT: lambda self: self.expression(exp.Not, this=self._parse_equality()),
 856        TokenType.TILDA: lambda self: self.expression(exp.BitwiseNot, this=self._parse_unary()),
 857        TokenType.DASH: lambda self: self.expression(exp.Neg, this=self._parse_unary()),
 858        TokenType.PIPE_SLASH: lambda self: self.expression(exp.Sqrt, this=self._parse_unary()),
 859        TokenType.DPIPE_SLASH: lambda self: self.expression(exp.Cbrt, this=self._parse_unary()),
 860    }
 861
 862    STRING_PARSERS = {
 863        TokenType.HEREDOC_STRING: lambda self, token: self.expression(
 864            exp.RawString, this=token.text
 865        ),
 866        TokenType.NATIONAL_STRING: lambda self, token: self.expression(
 867            exp.National, this=token.text
 868        ),
 869        TokenType.RAW_STRING: lambda self, token: self.expression(exp.RawString, this=token.text),
 870        TokenType.STRING: lambda self, token: self.expression(
 871            exp.Literal, this=token.text, is_string=True
 872        ),
 873        TokenType.UNICODE_STRING: lambda self, token: self.expression(
 874            exp.UnicodeString,
 875            this=token.text,
 876            escape=self._match_text_seq("UESCAPE") and self._parse_string(),
 877        ),
 878    }
 879
 880    NUMERIC_PARSERS = {
 881        TokenType.BIT_STRING: lambda self, token: self.expression(exp.BitString, this=token.text),
 882        TokenType.BYTE_STRING: lambda self, token: self.expression(exp.ByteString, this=token.text),
 883        TokenType.HEX_STRING: lambda self, token: self.expression(
 884            exp.HexString,
 885            this=token.text,
 886            is_integer=self.dialect.HEX_STRING_IS_INTEGER_TYPE or None,
 887        ),
 888        TokenType.NUMBER: lambda self, token: self.expression(
 889            exp.Literal, this=token.text, is_string=False
 890        ),
 891    }
 892
 893    PRIMARY_PARSERS = {
 894        **STRING_PARSERS,
 895        **NUMERIC_PARSERS,
 896        TokenType.INTRODUCER: lambda self, token: self._parse_introducer(token),
 897        TokenType.NULL: lambda self, _: self.expression(exp.Null),
 898        TokenType.TRUE: lambda self, _: self.expression(exp.Boolean, this=True),
 899        TokenType.FALSE: lambda self, _: self.expression(exp.Boolean, this=False),
 900        TokenType.SESSION_PARAMETER: lambda self, _: self._parse_session_parameter(),
 901        TokenType.STAR: lambda self, _: self._parse_star_ops(),
 902    }
 903
 904    PLACEHOLDER_PARSERS = {
 905        TokenType.PLACEHOLDER: lambda self: self.expression(exp.Placeholder),
 906        TokenType.PARAMETER: lambda self: self._parse_parameter(),
 907        TokenType.COLON: lambda self: (
 908            self.expression(exp.Placeholder, this=self._prev.text)
 909            if self._match_set(self.COLON_PLACEHOLDER_TOKENS)
 910            else None
 911        ),
 912    }
 913
 914    RANGE_PARSERS = {
 915        TokenType.AT_GT: binary_range_parser(exp.ArrayContainsAll),
 916        TokenType.BETWEEN: lambda self, this: self._parse_between(this),
 917        TokenType.GLOB: binary_range_parser(exp.Glob),
 918        TokenType.ILIKE: binary_range_parser(exp.ILike),
 919        TokenType.IN: lambda self, this: self._parse_in(this),
 920        TokenType.IRLIKE: binary_range_parser(exp.RegexpILike),
 921        TokenType.IS: lambda self, this: self._parse_is(this),
 922        TokenType.LIKE: binary_range_parser(exp.Like),
 923        TokenType.LT_AT: binary_range_parser(exp.ArrayContainsAll, reverse_args=True),
 924        TokenType.OVERLAPS: binary_range_parser(exp.Overlaps),
 925        TokenType.RLIKE: binary_range_parser(exp.RegexpLike),
 926        TokenType.SIMILAR_TO: binary_range_parser(exp.SimilarTo),
 927        TokenType.FOR: lambda self, this: self._parse_comprehension(this),
 928    }
 929
 930    PROPERTY_PARSERS: t.Dict[str, t.Callable] = {
 931        "ALLOWED_VALUES": lambda self: self.expression(
 932            exp.AllowedValuesProperty, expressions=self._parse_csv(self._parse_primary)
 933        ),
 934        "ALGORITHM": lambda self: self._parse_property_assignment(exp.AlgorithmProperty),
 935        "AUTO": lambda self: self._parse_auto_property(),
 936        "AUTO_INCREMENT": lambda self: self._parse_property_assignment(exp.AutoIncrementProperty),
 937        "BACKUP": lambda self: self.expression(
 938            exp.BackupProperty, this=self._parse_var(any_token=True)
 939        ),
 940        "BLOCKCOMPRESSION": lambda self: self._parse_blockcompression(),
 941        "CHARSET": lambda self, **kwargs: self._parse_character_set(**kwargs),
 942        "CHARACTER SET": lambda self, **kwargs: self._parse_character_set(**kwargs),
 943        "CHECKSUM": lambda self: self._parse_checksum(),
 944        "CLUSTER BY": lambda self: self._parse_cluster(),
 945        "CLUSTERED": lambda self: self._parse_clustered_by(),
 946        "COLLATE": lambda self, **kwargs: self._parse_property_assignment(
 947            exp.CollateProperty, **kwargs
 948        ),
 949        "COMMENT": lambda self: self._parse_property_assignment(exp.SchemaCommentProperty),
 950        "CONTAINS": lambda self: self._parse_contains_property(),
 951        "COPY": lambda self: self._parse_copy_property(),
 952        "DATABLOCKSIZE": lambda self, **kwargs: self._parse_datablocksize(**kwargs),
 953        "DATA_DELETION": lambda self: self._parse_data_deletion_property(),
 954        "DEFINER": lambda self: self._parse_definer(),
 955        "DETERMINISTIC": lambda self: self.expression(
 956            exp.StabilityProperty, this=exp.Literal.string("IMMUTABLE")
 957        ),
 958        "DISTRIBUTED": lambda self: self._parse_distributed_property(),
 959        "DUPLICATE": lambda self: self._parse_composite_key_property(exp.DuplicateKeyProperty),
 960        "DYNAMIC": lambda self: self.expression(exp.DynamicProperty),
 961        "DISTKEY": lambda self: self._parse_distkey(),
 962        "DISTSTYLE": lambda self: self._parse_property_assignment(exp.DistStyleProperty),
 963        "EMPTY": lambda self: self.expression(exp.EmptyProperty),
 964        "ENGINE": lambda self: self._parse_property_assignment(exp.EngineProperty),
 965        "EXECUTE": lambda self: self._parse_property_assignment(exp.ExecuteAsProperty),
 966        "EXTERNAL": lambda self: self.expression(exp.ExternalProperty),
 967        "FALLBACK": lambda self, **kwargs: self._parse_fallback(**kwargs),
 968        "FORMAT": lambda self: self._parse_property_assignment(exp.FileFormatProperty),
 969        "FREESPACE": lambda self: self._parse_freespace(),
 970        "GLOBAL": lambda self: self.expression(exp.GlobalProperty),
 971        "HEAP": lambda self: self.expression(exp.HeapProperty),
 972        "ICEBERG": lambda self: self.expression(exp.IcebergProperty),
 973        "IMMUTABLE": lambda self: self.expression(
 974            exp.StabilityProperty, this=exp.Literal.string("IMMUTABLE")
 975        ),
 976        "INHERITS": lambda self: self.expression(
 977            exp.InheritsProperty, expressions=self._parse_wrapped_csv(self._parse_table)
 978        ),
 979        "INPUT": lambda self: self.expression(exp.InputModelProperty, this=self._parse_schema()),
 980        "JOURNAL": lambda self, **kwargs: self._parse_journal(**kwargs),
 981        "LANGUAGE": lambda self: self._parse_property_assignment(exp.LanguageProperty),
 982        "LAYOUT": lambda self: self._parse_dict_property(this="LAYOUT"),
 983        "LIFETIME": lambda self: self._parse_dict_range(this="LIFETIME"),
 984        "LIKE": lambda self: self._parse_create_like(),
 985        "LOCATION": lambda self: self._parse_property_assignment(exp.LocationProperty),
 986        "LOCK": lambda self: self._parse_locking(),
 987        "LOCKING": lambda self: self._parse_locking(),
 988        "LOG": lambda self, **kwargs: self._parse_log(**kwargs),
 989        "MATERIALIZED": lambda self: self.expression(exp.MaterializedProperty),
 990        "MERGEBLOCKRATIO": lambda self, **kwargs: self._parse_mergeblockratio(**kwargs),
 991        "MODIFIES": lambda self: self._parse_modifies_property(),
 992        "MULTISET": lambda self: self.expression(exp.SetProperty, multi=True),
 993        "NO": lambda self: self._parse_no_property(),
 994        "ON": lambda self: self._parse_on_property(),
 995        "ORDER BY": lambda self: self._parse_order(skip_order_token=True),
 996        "OUTPUT": lambda self: self.expression(exp.OutputModelProperty, this=self._parse_schema()),
 997        "PARTITION": lambda self: self._parse_partitioned_of(),
 998        "PARTITION BY": lambda self: self._parse_partitioned_by(),
 999        "PARTITIONED BY": lambda self: self._parse_partitioned_by(),
1000        "PARTITIONED_BY": lambda self: self._parse_partitioned_by(),
1001        "PRIMARY KEY": lambda self: self._parse_primary_key(in_props=True),
1002        "RANGE": lambda self: self._parse_dict_range(this="RANGE"),
1003        "READS": lambda self: self._parse_reads_property(),
1004        "REMOTE": lambda self: self._parse_remote_with_connection(),
1005        "RETURNS": lambda self: self._parse_returns(),
1006        "STRICT": lambda self: self.expression(exp.StrictProperty),
1007        "STREAMING": lambda self: self.expression(exp.StreamingTableProperty),
1008        "ROW": lambda self: self._parse_row(),
1009        "ROW_FORMAT": lambda self: self._parse_property_assignment(exp.RowFormatProperty),
1010        "SAMPLE": lambda self: self.expression(
1011            exp.SampleProperty, this=self._match_text_seq("BY") and self._parse_bitwise()
1012        ),
1013        "SECURE": lambda self: self.expression(exp.SecureProperty),
1014        "SECURITY": lambda self: self._parse_security(),
1015        "SET": lambda self: self.expression(exp.SetProperty, multi=False),
1016        "SETTINGS": lambda self: self._parse_settings_property(),
1017        "SHARING": lambda self: self._parse_property_assignment(exp.SharingProperty),
1018        "SORTKEY": lambda self: self._parse_sortkey(),
1019        "SOURCE": lambda self: self._parse_dict_property(this="SOURCE"),
1020        "STABLE": lambda self: self.expression(
1021            exp.StabilityProperty, this=exp.Literal.string("STABLE")
1022        ),
1023        "STORED": lambda self: self._parse_stored(),
1024        "SYSTEM_VERSIONING": lambda self: self._parse_system_versioning_property(),
1025        "TBLPROPERTIES": lambda self: self._parse_wrapped_properties(),
1026        "TEMP": lambda self: self.expression(exp.TemporaryProperty),
1027        "TEMPORARY": lambda self: self.expression(exp.TemporaryProperty),
1028        "TO": lambda self: self._parse_to_table(),
1029        "TRANSIENT": lambda self: self.expression(exp.TransientProperty),
1030        "TRANSFORM": lambda self: self.expression(
1031            exp.TransformModelProperty, expressions=self._parse_wrapped_csv(self._parse_expression)
1032        ),
1033        "TTL": lambda self: self._parse_ttl(),
1034        "USING": lambda self: self._parse_property_assignment(exp.FileFormatProperty),
1035        "UNLOGGED": lambda self: self.expression(exp.UnloggedProperty),
1036        "VOLATILE": lambda self: self._parse_volatile_property(),
1037        "WITH": lambda self: self._parse_with_property(),
1038    }
1039
1040    CONSTRAINT_PARSERS = {
1041        "AUTOINCREMENT": lambda self: self._parse_auto_increment(),
1042        "AUTO_INCREMENT": lambda self: self._parse_auto_increment(),
1043        "CASESPECIFIC": lambda self: self.expression(exp.CaseSpecificColumnConstraint, not_=False),
1044        "CHARACTER SET": lambda self: self.expression(
1045            exp.CharacterSetColumnConstraint, this=self._parse_var_or_string()
1046        ),
1047        "CHECK": lambda self: self.expression(
1048            exp.CheckColumnConstraint,
1049            this=self._parse_wrapped(self._parse_assignment),
1050            enforced=self._match_text_seq("ENFORCED"),
1051        ),
1052        "COLLATE": lambda self: self.expression(
1053            exp.CollateColumnConstraint,
1054            this=self._parse_identifier() or self._parse_column(),
1055        ),
1056        "COMMENT": lambda self: self.expression(
1057            exp.CommentColumnConstraint, this=self._parse_string()
1058        ),
1059        "COMPRESS": lambda self: self._parse_compress(),
1060        "CLUSTERED": lambda self: self.expression(
1061            exp.ClusteredColumnConstraint, this=self._parse_wrapped_csv(self._parse_ordered)
1062        ),
1063        "NONCLUSTERED": lambda self: self.expression(
1064            exp.NonClusteredColumnConstraint, this=self._parse_wrapped_csv(self._parse_ordered)
1065        ),
1066        "DEFAULT": lambda self: self.expression(
1067            exp.DefaultColumnConstraint, this=self._parse_bitwise()
1068        ),
1069        "ENCODE": lambda self: self.expression(exp.EncodeColumnConstraint, this=self._parse_var()),
1070        "EPHEMERAL": lambda self: self.expression(
1071            exp.EphemeralColumnConstraint, this=self._parse_bitwise()
1072        ),
1073        "EXCLUDE": lambda self: self.expression(
1074            exp.ExcludeColumnConstraint, this=self._parse_index_params()
1075        ),
1076        "FOREIGN KEY": lambda self: self._parse_foreign_key(),
1077        "FORMAT": lambda self: self.expression(
1078            exp.DateFormatColumnConstraint, this=self._parse_var_or_string()
1079        ),
1080        "GENERATED": lambda self: self._parse_generated_as_identity(),
1081        "IDENTITY": lambda self: self._parse_auto_increment(),
1082        "INLINE": lambda self: self._parse_inline(),
1083        "LIKE": lambda self: self._parse_create_like(),
1084        "NOT": lambda self: self._parse_not_constraint(),
1085        "NULL": lambda self: self.expression(exp.NotNullColumnConstraint, allow_null=True),
1086        "ON": lambda self: (
1087            self._match(TokenType.UPDATE)
1088            and self.expression(exp.OnUpdateColumnConstraint, this=self._parse_function())
1089        )
1090        or self.expression(exp.OnProperty, this=self._parse_id_var()),
1091        "PATH": lambda self: self.expression(exp.PathColumnConstraint, this=self._parse_string()),
1092        "PERIOD": lambda self: self._parse_period_for_system_time(),
1093        "PRIMARY KEY": lambda self: self._parse_primary_key(),
1094        "REFERENCES": lambda self: self._parse_references(match=False),
1095        "TITLE": lambda self: self.expression(
1096            exp.TitleColumnConstraint, this=self._parse_var_or_string()
1097        ),
1098        "TTL": lambda self: self.expression(exp.MergeTreeTTL, expressions=[self._parse_bitwise()]),
1099        "UNIQUE": lambda self: self._parse_unique(),
1100        "UPPERCASE": lambda self: self.expression(exp.UppercaseColumnConstraint),
1101        "WATERMARK": lambda self: self.expression(
1102            exp.WatermarkColumnConstraint,
1103            this=self._match(TokenType.FOR) and self._parse_column(),
1104            expression=self._match(TokenType.ALIAS) and self._parse_disjunction(),
1105        ),
1106        "WITH": lambda self: self.expression(
1107            exp.Properties, expressions=self._parse_wrapped_properties()
1108        ),
1109        "BUCKET": lambda self: self._parse_partitioned_by_bucket_or_truncate(),
1110        "TRUNCATE": lambda self: self._parse_partitioned_by_bucket_or_truncate(),
1111    }
1112
1113    def _parse_partitioned_by_bucket_or_truncate(self) -> exp.Expression:
1114        klass = (
1115            exp.PartitionedByBucket
1116            if self._prev.text.upper() == "BUCKET"
1117            else exp.PartitionByTruncate
1118        )
1119
1120        args = self._parse_wrapped_csv(lambda: self._parse_primary() or self._parse_column())
1121        this, expression = seq_get(args, 0), seq_get(args, 1)
1122
1123        if isinstance(this, exp.Literal):
1124            # Check for Iceberg partition transforms (bucket / truncate) and ensure their arguments are in the right order
1125            #  - For Hive, it's `bucket(<num buckets>, <col name>)` or `truncate(<num_chars>, <col_name>)`
1126            #  - For Trino, it's reversed - `bucket(<col name>, <num buckets>)` or `truncate(<col_name>, <num_chars>)`
1127            # Both variants are canonicalized in the latter i.e `bucket(<col name>, <num buckets>)`
1128            #
1129            # Hive ref: https://docs.aws.amazon.com/athena/latest/ug/querying-iceberg-creating-tables.html#querying-iceberg-partitioning
1130            # Trino ref: https://docs.aws.amazon.com/athena/latest/ug/create-table-as.html#ctas-table-properties
1131            this, expression = expression, this
1132
1133        return self.expression(klass, this=this, expression=expression)
1134
1135    ALTER_PARSERS = {
1136        "ADD": lambda self: self._parse_alter_table_add(),
1137        "AS": lambda self: self._parse_select(),
1138        "ALTER": lambda self: self._parse_alter_table_alter(),
1139        "CLUSTER BY": lambda self: self._parse_cluster(wrapped=True),
1140        "DELETE": lambda self: self.expression(exp.Delete, where=self._parse_where()),
1141        "DROP": lambda self: self._parse_alter_table_drop(),
1142        "RENAME": lambda self: self._parse_alter_table_rename(),
1143        "SET": lambda self: self._parse_alter_table_set(),
1144        "SWAP": lambda self: self.expression(
1145            exp.SwapTable, this=self._match(TokenType.WITH) and self._parse_table(schema=True)
1146        ),
1147    }
1148
1149    ALTER_ALTER_PARSERS = {
1150        "DISTKEY": lambda self: self._parse_alter_diststyle(),
1151        "DISTSTYLE": lambda self: self._parse_alter_diststyle(),
1152        "SORTKEY": lambda self: self._parse_alter_sortkey(),
1153        "COMPOUND": lambda self: self._parse_alter_sortkey(compound=True),
1154    }
1155
1156    SCHEMA_UNNAMED_CONSTRAINTS = {
1157        "CHECK",
1158        "EXCLUDE",
1159        "FOREIGN KEY",
1160        "LIKE",
1161        "PERIOD",
1162        "PRIMARY KEY",
1163        "UNIQUE",
1164        "WATERMARK",
1165        "BUCKET",
1166        "TRUNCATE",
1167    }
1168
1169    NO_PAREN_FUNCTION_PARSERS = {
1170        "ANY": lambda self: self.expression(exp.Any, this=self._parse_bitwise()),
1171        "CASE": lambda self: self._parse_case(),
1172        "CONNECT_BY_ROOT": lambda self: self.expression(
1173            exp.ConnectByRoot, this=self._parse_column()
1174        ),
1175        "IF": lambda self: self._parse_if(),
1176    }
1177
1178    INVALID_FUNC_NAME_TOKENS = {
1179        TokenType.IDENTIFIER,
1180        TokenType.STRING,
1181    }
1182
1183    FUNCTIONS_WITH_ALIASED_ARGS = {"STRUCT"}
1184
1185    KEY_VALUE_DEFINITIONS = (exp.Alias, exp.EQ, exp.PropertyEQ, exp.Slice)
1186
1187    FUNCTION_PARSERS = {
1188        **{
1189            name: lambda self: self._parse_max_min_by(exp.ArgMax) for name in exp.ArgMax.sql_names()
1190        },
1191        **{
1192            name: lambda self: self._parse_max_min_by(exp.ArgMin) for name in exp.ArgMin.sql_names()
1193        },
1194        "CAST": lambda self: self._parse_cast(self.STRICT_CAST),
1195        "CEIL": lambda self: self._parse_ceil_floor(exp.Ceil),
1196        "CONVERT": lambda self: self._parse_convert(self.STRICT_CAST),
1197        "DECODE": lambda self: self._parse_decode(),
1198        "EXTRACT": lambda self: self._parse_extract(),
1199        "FLOOR": lambda self: self._parse_ceil_floor(exp.Floor),
1200        "GAP_FILL": lambda self: self._parse_gap_fill(),
1201        "JSON_OBJECT": lambda self: self._parse_json_object(),
1202        "JSON_OBJECTAGG": lambda self: self._parse_json_object(agg=True),
1203        "JSON_TABLE": lambda self: self._parse_json_table(),
1204        "MATCH": lambda self: self._parse_match_against(),
1205        "NORMALIZE": lambda self: self._parse_normalize(),
1206        "OPENJSON": lambda self: self._parse_open_json(),
1207        "OVERLAY": lambda self: self._parse_overlay(),
1208        "POSITION": lambda self: self._parse_position(),
1209        "PREDICT": lambda self: self._parse_predict(),
1210        "SAFE_CAST": lambda self: self._parse_cast(False, safe=True),
1211        "STRING_AGG": lambda self: self._parse_string_agg(),
1212        "SUBSTRING": lambda self: self._parse_substring(),
1213        "TRIM": lambda self: self._parse_trim(),
1214        "TRY_CAST": lambda self: self._parse_cast(False, safe=True),
1215        "TRY_CONVERT": lambda self: self._parse_convert(False, safe=True),
1216        "XMLELEMENT": lambda self: self.expression(
1217            exp.XMLElement,
1218            this=self._match_text_seq("NAME") and self._parse_id_var(),
1219            expressions=self._match(TokenType.COMMA) and self._parse_csv(self._parse_expression),
1220        ),
1221        "XMLTABLE": lambda self: self._parse_xml_table(),
1222    }
1223
1224    QUERY_MODIFIER_PARSERS = {
1225        TokenType.MATCH_RECOGNIZE: lambda self: ("match", self._parse_match_recognize()),
1226        TokenType.PREWHERE: lambda self: ("prewhere", self._parse_prewhere()),
1227        TokenType.WHERE: lambda self: ("where", self._parse_where()),
1228        TokenType.GROUP_BY: lambda self: ("group", self._parse_group()),
1229        TokenType.HAVING: lambda self: ("having", self._parse_having()),
1230        TokenType.QUALIFY: lambda self: ("qualify", self._parse_qualify()),
1231        TokenType.WINDOW: lambda self: ("windows", self._parse_window_clause()),
1232        TokenType.ORDER_BY: lambda self: ("order", self._parse_order()),
1233        TokenType.LIMIT: lambda self: ("limit", self._parse_limit()),
1234        TokenType.FETCH: lambda self: ("limit", self._parse_limit()),
1235        TokenType.OFFSET: lambda self: ("offset", self._parse_offset()),
1236        TokenType.FOR: lambda self: ("locks", self._parse_locks()),
1237        TokenType.LOCK: lambda self: ("locks", self._parse_locks()),
1238        TokenType.TABLE_SAMPLE: lambda self: ("sample", self._parse_table_sample(as_modifier=True)),
1239        TokenType.USING: lambda self: ("sample", self._parse_table_sample(as_modifier=True)),
1240        TokenType.CLUSTER_BY: lambda self: (
1241            "cluster",
1242            self._parse_sort(exp.Cluster, TokenType.CLUSTER_BY),
1243        ),
1244        TokenType.DISTRIBUTE_BY: lambda self: (
1245            "distribute",
1246            self._parse_sort(exp.Distribute, TokenType.DISTRIBUTE_BY),
1247        ),
1248        TokenType.SORT_BY: lambda self: ("sort", self._parse_sort(exp.Sort, TokenType.SORT_BY)),
1249        TokenType.CONNECT_BY: lambda self: ("connect", self._parse_connect(skip_start_token=True)),
1250        TokenType.START_WITH: lambda self: ("connect", self._parse_connect()),
1251    }
1252
1253    SET_PARSERS = {
1254        "GLOBAL": lambda self: self._parse_set_item_assignment("GLOBAL"),
1255        "LOCAL": lambda self: self._parse_set_item_assignment("LOCAL"),
1256        "SESSION": lambda self: self._parse_set_item_assignment("SESSION"),
1257        "TRANSACTION": lambda self: self._parse_set_transaction(),
1258    }
1259
1260    SHOW_PARSERS: t.Dict[str, t.Callable] = {}
1261
1262    TYPE_LITERAL_PARSERS = {
1263        exp.DataType.Type.JSON: lambda self, this, _: self.expression(exp.ParseJSON, this=this),
1264    }
1265
1266    TYPE_CONVERTERS: t.Dict[exp.DataType.Type, t.Callable[[exp.DataType], exp.DataType]] = {}
1267
1268    DDL_SELECT_TOKENS = {TokenType.SELECT, TokenType.WITH, TokenType.L_PAREN}
1269
1270    PRE_VOLATILE_TOKENS = {TokenType.CREATE, TokenType.REPLACE, TokenType.UNIQUE}
1271
1272    TRANSACTION_KIND = {"DEFERRED", "IMMEDIATE", "EXCLUSIVE"}
1273    TRANSACTION_CHARACTERISTICS: OPTIONS_TYPE = {
1274        "ISOLATION": (
1275            ("LEVEL", "REPEATABLE", "READ"),
1276            ("LEVEL", "READ", "COMMITTED"),
1277            ("LEVEL", "READ", "UNCOMITTED"),
1278            ("LEVEL", "SERIALIZABLE"),
1279        ),
1280        "READ": ("WRITE", "ONLY"),
1281    }
1282
1283    CONFLICT_ACTIONS: OPTIONS_TYPE = dict.fromkeys(
1284        ("ABORT", "FAIL", "IGNORE", "REPLACE", "ROLLBACK", "UPDATE"), tuple()
1285    )
1286    CONFLICT_ACTIONS["DO"] = ("NOTHING", "UPDATE")
1287
1288    CREATE_SEQUENCE: OPTIONS_TYPE = {
1289        "SCALE": ("EXTEND", "NOEXTEND"),
1290        "SHARD": ("EXTEND", "NOEXTEND"),
1291        "NO": ("CYCLE", "CACHE", "MAXVALUE", "MINVALUE"),
1292        **dict.fromkeys(
1293            (
1294                "SESSION",
1295                "GLOBAL",
1296                "KEEP",
1297                "NOKEEP",
1298                "ORDER",
1299                "NOORDER",
1300                "NOCACHE",
1301                "CYCLE",
1302                "NOCYCLE",
1303                "NOMINVALUE",
1304                "NOMAXVALUE",
1305                "NOSCALE",
1306                "NOSHARD",
1307            ),
1308            tuple(),
1309        ),
1310    }
1311
1312    ISOLATED_LOADING_OPTIONS: OPTIONS_TYPE = {"FOR": ("ALL", "INSERT", "NONE")}
1313
1314    USABLES: OPTIONS_TYPE = dict.fromkeys(
1315        ("ROLE", "WAREHOUSE", "DATABASE", "SCHEMA", "CATALOG"), tuple()
1316    )
1317
1318    CAST_ACTIONS: OPTIONS_TYPE = dict.fromkeys(("RENAME", "ADD"), ("FIELDS",))
1319
1320    SCHEMA_BINDING_OPTIONS: OPTIONS_TYPE = {
1321        "TYPE": ("EVOLUTION",),
1322        **dict.fromkeys(("BINDING", "COMPENSATION", "EVOLUTION"), tuple()),
1323    }
1324
1325    PROCEDURE_OPTIONS: OPTIONS_TYPE = {}
1326
1327    EXECUTE_AS_OPTIONS: OPTIONS_TYPE = dict.fromkeys(("CALLER", "SELF", "OWNER"), tuple())
1328
1329    KEY_CONSTRAINT_OPTIONS: OPTIONS_TYPE = {
1330        "NOT": ("ENFORCED",),
1331        "MATCH": (
1332            "FULL",
1333            "PARTIAL",
1334            "SIMPLE",
1335        ),
1336        "INITIALLY": ("DEFERRED", "IMMEDIATE"),
1337        "USING": (
1338            "BTREE",
1339            "HASH",
1340        ),
1341        **dict.fromkeys(("DEFERRABLE", "NORELY", "RELY"), tuple()),
1342    }
1343
1344    INSERT_ALTERNATIVES = {"ABORT", "FAIL", "IGNORE", "REPLACE", "ROLLBACK"}
1345
1346    CLONE_KEYWORDS = {"CLONE", "COPY"}
1347    HISTORICAL_DATA_PREFIX = {"AT", "BEFORE", "END"}
1348    HISTORICAL_DATA_KIND = {"TIMESTAMP", "OFFSET", "STATEMENT", "STREAM"}
1349
1350    OPCLASS_FOLLOW_KEYWORDS = {"ASC", "DESC", "NULLS", "WITH"}
1351
1352    OPTYPE_FOLLOW_TOKENS = {TokenType.COMMA, TokenType.R_PAREN}
1353
1354    TABLE_INDEX_HINT_TOKENS = {TokenType.FORCE, TokenType.IGNORE, TokenType.USE}
1355
1356    VIEW_ATTRIBUTES = {"ENCRYPTION", "SCHEMABINDING", "VIEW_METADATA"}
1357
1358    WINDOW_ALIAS_TOKENS = ID_VAR_TOKENS - {TokenType.ROWS}
1359    WINDOW_BEFORE_PAREN_TOKENS = {TokenType.OVER}
1360    WINDOW_SIDES = {"FOLLOWING", "PRECEDING"}
1361
1362    JSON_KEY_VALUE_SEPARATOR_TOKENS = {TokenType.COLON, TokenType.COMMA, TokenType.IS}
1363
1364    FETCH_TOKENS = ID_VAR_TOKENS - {TokenType.ROW, TokenType.ROWS, TokenType.PERCENT}
1365
1366    ADD_CONSTRAINT_TOKENS = {
1367        TokenType.CONSTRAINT,
1368        TokenType.FOREIGN_KEY,
1369        TokenType.INDEX,
1370        TokenType.KEY,
1371        TokenType.PRIMARY_KEY,
1372        TokenType.UNIQUE,
1373    }
1374
1375    DISTINCT_TOKENS = {TokenType.DISTINCT}
1376
1377    NULL_TOKENS = {TokenType.NULL}
1378
1379    UNNEST_OFFSET_ALIAS_TOKENS = TABLE_ALIAS_TOKENS - SET_OPERATIONS
1380
1381    SELECT_START_TOKENS = {TokenType.L_PAREN, TokenType.WITH, TokenType.SELECT}
1382
1383    COPY_INTO_VARLEN_OPTIONS = {"FILE_FORMAT", "COPY_OPTIONS", "FORMAT_OPTIONS", "CREDENTIAL"}
1384
1385    IS_JSON_PREDICATE_KIND = {"VALUE", "SCALAR", "ARRAY", "OBJECT"}
1386
1387    ODBC_DATETIME_LITERALS = {
1388        "d": exp.Date,
1389        "t": exp.Time,
1390        "ts": exp.Timestamp,
1391    }
1392
1393    ON_CONDITION_TOKENS = {"ERROR", "NULL", "TRUE", "FALSE", "EMPTY"}
1394
1395    PRIVILEGE_FOLLOW_TOKENS = {TokenType.ON, TokenType.COMMA, TokenType.L_PAREN}
1396
1397    # The style options for the DESCRIBE statement
1398    DESCRIBE_STYLES = {"ANALYZE", "EXTENDED", "FORMATTED", "HISTORY"}
1399
1400    # The style options for the ANALYZE statement
1401    ANALYZE_STYLES = {
1402        "BUFFER_USAGE_LIMIT",
1403        "FULL",
1404        "LOCAL",
1405        "NO_WRITE_TO_BINLOG",
1406        "SAMPLE",
1407        "SKIP_LOCKED",
1408        "VERBOSE",
1409    }
1410
1411    ANALYZE_EXPRESSION_PARSERS = {
1412        "ALL": lambda self: self._parse_analyze_columns(),
1413        "COMPUTE": lambda self: self._parse_analyze_statistics(),
1414        "DELETE": lambda self: self._parse_analyze_delete(),
1415        "DROP": lambda self: self._parse_analyze_histogram(),
1416        "ESTIMATE": lambda self: self._parse_analyze_statistics(),
1417        "LIST": lambda self: self._parse_analyze_list(),
1418        "PREDICATE": lambda self: self._parse_analyze_columns(),
1419        "UPDATE": lambda self: self._parse_analyze_histogram(),
1420        "VALIDATE": lambda self: self._parse_analyze_validate(),
1421    }
1422
1423    PARTITION_KEYWORDS = {"PARTITION", "SUBPARTITION"}
1424
1425    AMBIGUOUS_ALIAS_TOKENS = (TokenType.LIMIT, TokenType.OFFSET)
1426
1427    OPERATION_MODIFIERS: t.Set[str] = set()
1428
1429    RECURSIVE_CTE_SEARCH_KIND = {"BREADTH", "DEPTH", "CYCLE"}
1430
1431    MODIFIABLES = (exp.Query, exp.Table, exp.TableFromRows)
1432
1433    STRICT_CAST = True
1434
1435    PREFIXED_PIVOT_COLUMNS = False
1436    IDENTIFY_PIVOT_STRINGS = False
1437
1438    LOG_DEFAULTS_TO_LN = False
1439
1440    # Whether ADD is present for each column added by ALTER TABLE
1441    ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN = True
1442
1443    # Whether the table sample clause expects CSV syntax
1444    TABLESAMPLE_CSV = False
1445
1446    # The default method used for table sampling
1447    DEFAULT_SAMPLING_METHOD: t.Optional[str] = None
1448
1449    # Whether the SET command needs a delimiter (e.g. "=") for assignments
1450    SET_REQUIRES_ASSIGNMENT_DELIMITER = True
1451
1452    # Whether the TRIM function expects the characters to trim as its first argument
1453    TRIM_PATTERN_FIRST = False
1454
1455    # Whether string aliases are supported `SELECT COUNT(*) 'count'`
1456    STRING_ALIASES = False
1457
1458    # Whether query modifiers such as LIMIT are attached to the UNION node (vs its right operand)
1459    MODIFIERS_ATTACHED_TO_SET_OP = True
1460    SET_OP_MODIFIERS = {"order", "limit", "offset"}
1461
1462    # Whether to parse IF statements that aren't followed by a left parenthesis as commands
1463    NO_PAREN_IF_COMMANDS = True
1464
1465    # Whether the -> and ->> operators expect documents of type JSON (e.g. Postgres)
1466    JSON_ARROWS_REQUIRE_JSON_TYPE = False
1467
1468    # Whether the `:` operator is used to extract a value from a VARIANT column
1469    COLON_IS_VARIANT_EXTRACT = False
1470
1471    # Whether or not a VALUES keyword needs to be followed by '(' to form a VALUES clause.
1472    # If this is True and '(' is not found, the keyword will be treated as an identifier
1473    VALUES_FOLLOWED_BY_PAREN = True
1474
1475    # Whether implicit unnesting is supported, e.g. SELECT 1 FROM y.z AS z, z.a (Redshift)
1476    SUPPORTS_IMPLICIT_UNNEST = False
1477
1478    # Whether or not interval spans are supported, INTERVAL 1 YEAR TO MONTHS
1479    INTERVAL_SPANS = True
1480
1481    # Whether a PARTITION clause can follow a table reference
1482    SUPPORTS_PARTITION_SELECTION = False
1483
1484    # Whether the `name AS expr` schema/column constraint requires parentheses around `expr`
1485    WRAPPED_TRANSFORM_COLUMN_CONSTRAINT = True
1486
1487    # Whether the 'AS' keyword is optional in the CTE definition syntax
1488    OPTIONAL_ALIAS_TOKEN_CTE = True
1489
1490    __slots__ = (
1491        "error_level",
1492        "error_message_context",
1493        "max_errors",
1494        "dialect",
1495        "sql",
1496        "errors",
1497        "_tokens",
1498        "_index",
1499        "_curr",
1500        "_next",
1501        "_prev",
1502        "_prev_comments",
1503    )
1504
1505    # Autofilled
1506    SHOW_TRIE: t.Dict = {}
1507    SET_TRIE: t.Dict = {}
1508
1509    def __init__(
1510        self,
1511        error_level: t.Optional[ErrorLevel] = None,
1512        error_message_context: int = 100,
1513        max_errors: int = 3,
1514        dialect: DialectType = None,
1515    ):
1516        from sqlglot.dialects import Dialect
1517
1518        self.error_level = error_level or ErrorLevel.IMMEDIATE
1519        self.error_message_context = error_message_context
1520        self.max_errors = max_errors
1521        self.dialect = Dialect.get_or_raise(dialect)
1522        self.reset()
1523
1524    def reset(self):
1525        self.sql = ""
1526        self.errors = []
1527        self._tokens = []
1528        self._index = 0
1529        self._curr = None
1530        self._next = None
1531        self._prev = None
1532        self._prev_comments = None
1533
1534    def parse(
1535        self, raw_tokens: t.List[Token], sql: t.Optional[str] = None
1536    ) -> t.List[t.Optional[exp.Expression]]:
1537        """
1538        Parses a list of tokens and returns a list of syntax trees, one tree
1539        per parsed SQL statement.
1540
1541        Args:
1542            raw_tokens: The list of tokens.
1543            sql: The original SQL string, used to produce helpful debug messages.
1544
1545        Returns:
1546            The list of the produced syntax trees.
1547        """
1548        return self._parse(
1549            parse_method=self.__class__._parse_statement, raw_tokens=raw_tokens, sql=sql
1550        )
1551
1552    def parse_into(
1553        self,
1554        expression_types: exp.IntoType,
1555        raw_tokens: t.List[Token],
1556        sql: t.Optional[str] = None,
1557    ) -> t.List[t.Optional[exp.Expression]]:
1558        """
1559        Parses a list of tokens into a given Expression type. If a collection of Expression
1560        types is given instead, this method will try to parse the token list into each one
1561        of them, stopping at the first for which the parsing succeeds.
1562
1563        Args:
1564            expression_types: The expression type(s) to try and parse the token list into.
1565            raw_tokens: The list of tokens.
1566            sql: The original SQL string, used to produce helpful debug messages.
1567
1568        Returns:
1569            The target Expression.
1570        """
1571        errors = []
1572        for expression_type in ensure_list(expression_types):
1573            parser = self.EXPRESSION_PARSERS.get(expression_type)
1574            if not parser:
1575                raise TypeError(f"No parser registered for {expression_type}")
1576
1577            try:
1578                return self._parse(parser, raw_tokens, sql)
1579            except ParseError as e:
1580                e.errors[0]["into_expression"] = expression_type
1581                errors.append(e)
1582
1583        raise ParseError(
1584            f"Failed to parse '{sql or raw_tokens}' into {expression_types}",
1585            errors=merge_errors(errors),
1586        ) from errors[-1]
1587
1588    def _parse(
1589        self,
1590        parse_method: t.Callable[[Parser], t.Optional[exp.Expression]],
1591        raw_tokens: t.List[Token],
1592        sql: t.Optional[str] = None,
1593    ) -> t.List[t.Optional[exp.Expression]]:
1594        self.reset()
1595        self.sql = sql or ""
1596
1597        total = len(raw_tokens)
1598        chunks: t.List[t.List[Token]] = [[]]
1599
1600        for i, token in enumerate(raw_tokens):
1601            if token.token_type == TokenType.SEMICOLON:
1602                if token.comments:
1603                    chunks.append([token])
1604
1605                if i < total - 1:
1606                    chunks.append([])
1607            else:
1608                chunks[-1].append(token)
1609
1610        expressions = []
1611
1612        for tokens in chunks:
1613            self._index = -1
1614            self._tokens = tokens
1615            self._advance()
1616
1617            expressions.append(parse_method(self))
1618
1619            if self._index < len(self._tokens):
1620                self.raise_error("Invalid expression / Unexpected token")
1621
1622            self.check_errors()
1623
1624        return expressions
1625
1626    def check_errors(self) -> None:
1627        """Logs or raises any found errors, depending on the chosen error level setting."""
1628        if self.error_level == ErrorLevel.WARN:
1629            for error in self.errors:
1630                logger.error(str(error))
1631        elif self.error_level == ErrorLevel.RAISE and self.errors:
1632            raise ParseError(
1633                concat_messages(self.errors, self.max_errors),
1634                errors=merge_errors(self.errors),
1635            )
1636
1637    def raise_error(self, message: str, token: t.Optional[Token] = None) -> None:
1638        """
1639        Appends an error in the list of recorded errors or raises it, depending on the chosen
1640        error level setting.
1641        """
1642        token = token or self._curr or self._prev or Token.string("")
1643        start = token.start
1644        end = token.end + 1
1645        start_context = self.sql[max(start - self.error_message_context, 0) : start]
1646        highlight = self.sql[start:end]
1647        end_context = self.sql[end : end + self.error_message_context]
1648
1649        error = ParseError.new(
1650            f"{message}. Line {token.line}, Col: {token.col}.\n"
1651            f"  {start_context}\033[4m{highlight}\033[0m{end_context}",
1652            description=message,
1653            line=token.line,
1654            col=token.col,
1655            start_context=start_context,
1656            highlight=highlight,
1657            end_context=end_context,
1658        )
1659
1660        if self.error_level == ErrorLevel.IMMEDIATE:
1661            raise error
1662
1663        self.errors.append(error)
1664
1665    def expression(
1666        self, exp_class: t.Type[E], comments: t.Optional[t.List[str]] = None, **kwargs
1667    ) -> E:
1668        """
1669        Creates a new, validated Expression.
1670
1671        Args:
1672            exp_class: The expression class to instantiate.
1673            comments: An optional list of comments to attach to the expression.
1674            kwargs: The arguments to set for the expression along with their respective values.
1675
1676        Returns:
1677            The target expression.
1678        """
1679        instance = exp_class(**kwargs)
1680        instance.add_comments(comments) if comments else self._add_comments(instance)
1681        return self.validate_expression(instance)
1682
1683    def _add_comments(self, expression: t.Optional[exp.Expression]) -> None:
1684        if expression and self._prev_comments:
1685            expression.add_comments(self._prev_comments)
1686            self._prev_comments = None
1687
1688    def validate_expression(self, expression: E, args: t.Optional[t.List] = None) -> E:
1689        """
1690        Validates an Expression, making sure that all its mandatory arguments are set.
1691
1692        Args:
1693            expression: The expression to validate.
1694            args: An optional list of items that was used to instantiate the expression, if it's a Func.
1695
1696        Returns:
1697            The validated expression.
1698        """
1699        if self.error_level != ErrorLevel.IGNORE:
1700            for error_message in expression.error_messages(args):
1701                self.raise_error(error_message)
1702
1703        return expression
1704
1705    def _find_sql(self, start: Token, end: Token) -> str:
1706        return self.sql[start.start : end.end + 1]
1707
1708    def _is_connected(self) -> bool:
1709        return self._prev and self._curr and self._prev.end + 1 == self._curr.start
1710
1711    def _advance(self, times: int = 1) -> None:
1712        self._index += times
1713        self._curr = seq_get(self._tokens, self._index)
1714        self._next = seq_get(self._tokens, self._index + 1)
1715
1716        if self._index > 0:
1717            self._prev = self._tokens[self._index - 1]
1718            self._prev_comments = self._prev.comments
1719        else:
1720            self._prev = None
1721            self._prev_comments = None
1722
1723    def _retreat(self, index: int) -> None:
1724        if index != self._index:
1725            self._advance(index - self._index)
1726
1727    def _warn_unsupported(self) -> None:
1728        if len(self._tokens) <= 1:
1729            return
1730
1731        # We use _find_sql because self.sql may comprise multiple chunks, and we're only
1732        # interested in emitting a warning for the one being currently processed.
1733        sql = self._find_sql(self._tokens[0], self._tokens[-1])[: self.error_message_context]
1734
1735        logger.warning(
1736            f"'{sql}' contains unsupported syntax. Falling back to parsing as a 'Command'."
1737        )
1738
1739    def _parse_command(self) -> exp.Command:
1740        self._warn_unsupported()
1741        return self.expression(
1742            exp.Command,
1743            comments=self._prev_comments,
1744            this=self._prev.text.upper(),
1745            expression=self._parse_string(),
1746        )
1747
1748    def _try_parse(self, parse_method: t.Callable[[], T], retreat: bool = False) -> t.Optional[T]:
1749        """
1750        Attemps to backtrack if a parse function that contains a try/catch internally raises an error.
1751        This behavior can be different depending on the uset-set ErrorLevel, so _try_parse aims to
1752        solve this by setting & resetting the parser state accordingly
1753        """
1754        index = self._index
1755        error_level = self.error_level
1756
1757        self.error_level = ErrorLevel.IMMEDIATE
1758        try:
1759            this = parse_method()
1760        except ParseError:
1761            this = None
1762        finally:
1763            if not this or retreat:
1764                self._retreat(index)
1765            self.error_level = error_level
1766
1767        return this
1768
1769    def _parse_comment(self, allow_exists: bool = True) -> exp.Expression:
1770        start = self._prev
1771        exists = self._parse_exists() if allow_exists else None
1772
1773        self._match(TokenType.ON)
1774
1775        materialized = self._match_text_seq("MATERIALIZED")
1776        kind = self._match_set(self.CREATABLES) and self._prev
1777        if not kind:
1778            return self._parse_as_command(start)
1779
1780        if kind.token_type in (TokenType.FUNCTION, TokenType.PROCEDURE):
1781            this = self._parse_user_defined_function(kind=kind.token_type)
1782        elif kind.token_type == TokenType.TABLE:
1783            this = self._parse_table(alias_tokens=self.COMMENT_TABLE_ALIAS_TOKENS)
1784        elif kind.token_type == TokenType.COLUMN:
1785            this = self._parse_column()
1786        else:
1787            this = self._parse_id_var()
1788
1789        self._match(TokenType.IS)
1790
1791        return self.expression(
1792            exp.Comment,
1793            this=this,
1794            kind=kind.text,
1795            expression=self._parse_string(),
1796            exists=exists,
1797            materialized=materialized,
1798        )
1799
1800    def _parse_to_table(
1801        self,
1802    ) -> exp.ToTableProperty:
1803        table = self._parse_table_parts(schema=True)
1804        return self.expression(exp.ToTableProperty, this=table)
1805
1806    # https://clickhouse.com/docs/en/engines/table-engines/mergetree-family/mergetree#mergetree-table-ttl
1807    def _parse_ttl(self) -> exp.Expression:
1808        def _parse_ttl_action() -> t.Optional[exp.Expression]:
1809            this = self._parse_bitwise()
1810
1811            if self._match_text_seq("DELETE"):
1812                return self.expression(exp.MergeTreeTTLAction, this=this, delete=True)
1813            if self._match_text_seq("RECOMPRESS"):
1814                return self.expression(
1815                    exp.MergeTreeTTLAction, this=this, recompress=self._parse_bitwise()
1816                )
1817            if self._match_text_seq("TO", "DISK"):
1818                return self.expression(
1819                    exp.MergeTreeTTLAction, this=this, to_disk=self._parse_string()
1820                )
1821            if self._match_text_seq("TO", "VOLUME"):
1822                return self.expression(
1823                    exp.MergeTreeTTLAction, this=this, to_volume=self._parse_string()
1824                )
1825
1826            return this
1827
1828        expressions = self._parse_csv(_parse_ttl_action)
1829        where = self._parse_where()
1830        group = self._parse_group()
1831
1832        aggregates = None
1833        if group and self._match(TokenType.SET):
1834            aggregates = self._parse_csv(self._parse_set_item)
1835
1836        return self.expression(
1837            exp.MergeTreeTTL,
1838            expressions=expressions,
1839            where=where,
1840            group=group,
1841            aggregates=aggregates,
1842        )
1843
1844    def _parse_statement(self) -> t.Optional[exp.Expression]:
1845        if self._curr is None:
1846            return None
1847
1848        if self._match_set(self.STATEMENT_PARSERS):
1849            comments = self._prev_comments
1850            stmt = self.STATEMENT_PARSERS[self._prev.token_type](self)
1851            stmt.add_comments(comments, prepend=True)
1852            return stmt
1853
1854        if self._match_set(self.dialect.tokenizer.COMMANDS):
1855            return self._parse_command()
1856
1857        expression = self._parse_expression()
1858        expression = self._parse_set_operations(expression) if expression else self._parse_select()
1859        return self._parse_query_modifiers(expression)
1860
1861    def _parse_drop(self, exists: bool = False) -> exp.Drop | exp.Command:
1862        start = self._prev
1863        temporary = self._match(TokenType.TEMPORARY)
1864        materialized = self._match_text_seq("MATERIALIZED")
1865
1866        kind = self._match_set(self.CREATABLES) and self._prev.text.upper()
1867        if not kind:
1868            return self._parse_as_command(start)
1869
1870        concurrently = self._match_text_seq("CONCURRENTLY")
1871        if_exists = exists or self._parse_exists()
1872
1873        if kind == "COLUMN":
1874            this = self._parse_column()
1875        else:
1876            this = self._parse_table_parts(
1877                schema=True, is_db_reference=self._prev.token_type == TokenType.SCHEMA
1878            )
1879
1880        cluster = self._parse_on_property() if self._match(TokenType.ON) else None
1881
1882        if self._match(TokenType.L_PAREN, advance=False):
1883            expressions = self._parse_wrapped_csv(self._parse_types)
1884        else:
1885            expressions = None
1886
1887        return self.expression(
1888            exp.Drop,
1889            exists=if_exists,
1890            this=this,
1891            expressions=expressions,
1892            kind=self.dialect.CREATABLE_KIND_MAPPING.get(kind) or kind,
1893            temporary=temporary,
1894            materialized=materialized,
1895            cascade=self._match_text_seq("CASCADE"),
1896            constraints=self._match_text_seq("CONSTRAINTS"),
1897            purge=self._match_text_seq("PURGE"),
1898            cluster=cluster,
1899            concurrently=concurrently,
1900        )
1901
1902    def _parse_exists(self, not_: bool = False) -> t.Optional[bool]:
1903        return (
1904            self._match_text_seq("IF")
1905            and (not not_ or self._match(TokenType.NOT))
1906            and self._match(TokenType.EXISTS)
1907        )
1908
1909    def _parse_create(self) -> exp.Create | exp.Command:
1910        # Note: this can't be None because we've matched a statement parser
1911        start = self._prev
1912
1913        replace = (
1914            start.token_type == TokenType.REPLACE
1915            or self._match_pair(TokenType.OR, TokenType.REPLACE)
1916            or self._match_pair(TokenType.OR, TokenType.ALTER)
1917        )
1918        refresh = self._match_pair(TokenType.OR, TokenType.REFRESH)
1919
1920        unique = self._match(TokenType.UNIQUE)
1921
1922        if self._match_text_seq("CLUSTERED", "COLUMNSTORE"):
1923            clustered = True
1924        elif self._match_text_seq("NONCLUSTERED", "COLUMNSTORE") or self._match_text_seq(
1925            "COLUMNSTORE"
1926        ):
1927            clustered = False
1928        else:
1929            clustered = None
1930
1931        if self._match_pair(TokenType.TABLE, TokenType.FUNCTION, advance=False):
1932            self._advance()
1933
1934        properties = None
1935        create_token = self._match_set(self.CREATABLES) and self._prev
1936
1937        if not create_token:
1938            # exp.Properties.Location.POST_CREATE
1939            properties = self._parse_properties()
1940            create_token = self._match_set(self.CREATABLES) and self._prev
1941
1942            if not properties or not create_token:
1943                return self._parse_as_command(start)
1944
1945        concurrently = self._match_text_seq("CONCURRENTLY")
1946        exists = self._parse_exists(not_=True)
1947        this = None
1948        expression: t.Optional[exp.Expression] = None
1949        indexes = None
1950        no_schema_binding = None
1951        begin = None
1952        end = None
1953        clone = None
1954
1955        def extend_props(temp_props: t.Optional[exp.Properties]) -> None:
1956            nonlocal properties
1957            if properties and temp_props:
1958                properties.expressions.extend(temp_props.expressions)
1959            elif temp_props:
1960                properties = temp_props
1961
1962        if create_token.token_type in (TokenType.FUNCTION, TokenType.PROCEDURE):
1963            this = self._parse_user_defined_function(kind=create_token.token_type)
1964
1965            # exp.Properties.Location.POST_SCHEMA ("schema" here is the UDF's type signature)
1966            extend_props(self._parse_properties())
1967
1968            expression = self._match(TokenType.ALIAS) and self._parse_heredoc()
1969            extend_props(self._parse_properties())
1970
1971            if not expression:
1972                if self._match(TokenType.COMMAND):
1973                    expression = self._parse_as_command(self._prev)
1974                else:
1975                    begin = self._match(TokenType.BEGIN)
1976                    return_ = self._match_text_seq("RETURN")
1977
1978                    if self._match(TokenType.STRING, advance=False):
1979                        # Takes care of BigQuery's JavaScript UDF definitions that end in an OPTIONS property
1980                        # # https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_function_statement
1981                        expression = self._parse_string()
1982                        extend_props(self._parse_properties())
1983                    else:
1984                        expression = self._parse_user_defined_function_expression()
1985
1986                    end = self._match_text_seq("END")
1987
1988                    if return_:
1989                        expression = self.expression(exp.Return, this=expression)
1990        elif create_token.token_type == TokenType.INDEX:
1991            # Postgres allows anonymous indexes, eg. CREATE INDEX IF NOT EXISTS ON t(c)
1992            if not self._match(TokenType.ON):
1993                index = self._parse_id_var()
1994                anonymous = False
1995            else:
1996                index = None
1997                anonymous = True
1998
1999            this = self._parse_index(index=index, anonymous=anonymous)
2000        elif create_token.token_type in self.DB_CREATABLES:
2001            table_parts = self._parse_table_parts(
2002                schema=True, is_db_reference=create_token.token_type == TokenType.SCHEMA
2003            )
2004
2005            # exp.Properties.Location.POST_NAME
2006            self._match(TokenType.COMMA)
2007            extend_props(self._parse_properties(before=True))
2008
2009            this = self._parse_schema(this=table_parts)
2010
2011            # exp.Properties.Location.POST_SCHEMA and POST_WITH
2012            extend_props(self._parse_properties())
2013
2014            has_alias = self._match(TokenType.ALIAS)
2015            if not self._match_set(self.DDL_SELECT_TOKENS, advance=False):
2016                # exp.Properties.Location.POST_ALIAS
2017                extend_props(self._parse_properties())
2018
2019            if create_token.token_type == TokenType.SEQUENCE:
2020                expression = self._parse_types()
2021                extend_props(self._parse_properties())
2022            else:
2023                expression = self._parse_ddl_select()
2024
2025                # Some dialects also support using a table as an alias instead of a SELECT.
2026                # Here we fallback to this as an alternative.
2027                if not expression and has_alias:
2028                    expression = self._try_parse(self._parse_table_parts)
2029
2030            if create_token.token_type == TokenType.TABLE:
2031                # exp.Properties.Location.POST_EXPRESSION
2032                extend_props(self._parse_properties())
2033
2034                indexes = []
2035                while True:
2036                    index = self._parse_index()
2037
2038                    # exp.Properties.Location.POST_INDEX
2039                    extend_props(self._parse_properties())
2040                    if not index:
2041                        break
2042                    else:
2043                        self._match(TokenType.COMMA)
2044                        indexes.append(index)
2045            elif create_token.token_type == TokenType.VIEW:
2046                if self._match_text_seq("WITH", "NO", "SCHEMA", "BINDING"):
2047                    no_schema_binding = True
2048            elif create_token.token_type in (TokenType.SINK, TokenType.SOURCE):
2049                extend_props(self._parse_properties())
2050
2051            shallow = self._match_text_seq("SHALLOW")
2052
2053            if self._match_texts(self.CLONE_KEYWORDS):
2054                copy = self._prev.text.lower() == "copy"
2055                clone = self.expression(
2056                    exp.Clone, this=self._parse_table(schema=True), shallow=shallow, copy=copy
2057                )
2058
2059        if self._curr and not self._match_set((TokenType.R_PAREN, TokenType.COMMA), advance=False):
2060            return self._parse_as_command(start)
2061
2062        create_kind_text = create_token.text.upper()
2063        return self.expression(
2064            exp.Create,
2065            this=this,
2066            kind=self.dialect.CREATABLE_KIND_MAPPING.get(create_kind_text) or create_kind_text,
2067            replace=replace,
2068            refresh=refresh,
2069            unique=unique,
2070            expression=expression,
2071            exists=exists,
2072            properties=properties,
2073            indexes=indexes,
2074            no_schema_binding=no_schema_binding,
2075            begin=begin,
2076            end=end,
2077            clone=clone,
2078            concurrently=concurrently,
2079            clustered=clustered,
2080        )
2081
2082    def _parse_sequence_properties(self) -> t.Optional[exp.SequenceProperties]:
2083        seq = exp.SequenceProperties()
2084
2085        options = []
2086        index = self._index
2087
2088        while self._curr:
2089            self._match(TokenType.COMMA)
2090            if self._match_text_seq("INCREMENT"):
2091                self._match_text_seq("BY")
2092                self._match_text_seq("=")
2093                seq.set("increment", self._parse_term())
2094            elif self._match_text_seq("MINVALUE"):
2095                seq.set("minvalue", self._parse_term())
2096            elif self._match_text_seq("MAXVALUE"):
2097                seq.set("maxvalue", self._parse_term())
2098            elif self._match(TokenType.START_WITH) or self._match_text_seq("START"):
2099                self._match_text_seq("=")
2100                seq.set("start", self._parse_term())
2101            elif self._match_text_seq("CACHE"):
2102                # T-SQL allows empty CACHE which is initialized dynamically
2103                seq.set("cache", self._parse_number() or True)
2104            elif self._match_text_seq("OWNED", "BY"):
2105                # "OWNED BY NONE" is the default
2106                seq.set("owned", None if self._match_text_seq("NONE") else self._parse_column())
2107            else:
2108                opt = self._parse_var_from_options(self.CREATE_SEQUENCE, raise_unmatched=False)
2109                if opt:
2110                    options.append(opt)
2111                else:
2112                    break
2113
2114        seq.set("options", options if options else None)
2115        return None if self._index == index else seq
2116
2117    def _parse_property_before(self) -> t.Optional[exp.Expression]:
2118        # only used for teradata currently
2119        self._match(TokenType.COMMA)
2120
2121        kwargs = {
2122            "no": self._match_text_seq("NO"),
2123            "dual": self._match_text_seq("DUAL"),
2124            "before": self._match_text_seq("BEFORE"),
2125            "default": self._match_text_seq("DEFAULT"),
2126            "local": (self._match_text_seq("LOCAL") and "LOCAL")
2127            or (self._match_text_seq("NOT", "LOCAL") and "NOT LOCAL"),
2128            "after": self._match_text_seq("AFTER"),
2129            "minimum": self._match_texts(("MIN", "MINIMUM")),
2130            "maximum": self._match_texts(("MAX", "MAXIMUM")),
2131        }
2132
2133        if self._match_texts(self.PROPERTY_PARSERS):
2134            parser = self.PROPERTY_PARSERS[self._prev.text.upper()]
2135            try:
2136                return parser(self, **{k: v for k, v in kwargs.items() if v})
2137            except TypeError:
2138                self.raise_error(f"Cannot parse property '{self._prev.text}'")
2139
2140        return None
2141
2142    def _parse_wrapped_properties(self) -> t.List[exp.Expression]:
2143        return self._parse_wrapped_csv(self._parse_property)
2144
2145    def _parse_property(self) -> t.Optional[exp.Expression]:
2146        if self._match_texts(self.PROPERTY_PARSERS):
2147            return self.PROPERTY_PARSERS[self._prev.text.upper()](self)
2148
2149        if self._match(TokenType.DEFAULT) and self._match_texts(self.PROPERTY_PARSERS):
2150            return self.PROPERTY_PARSERS[self._prev.text.upper()](self, default=True)
2151
2152        if self._match_text_seq("COMPOUND", "SORTKEY"):
2153            return self._parse_sortkey(compound=True)
2154
2155        if self._match_text_seq("SQL", "SECURITY"):
2156            return self.expression(exp.SqlSecurityProperty, definer=self._match_text_seq("DEFINER"))
2157
2158        index = self._index
2159        key = self._parse_column()
2160
2161        if not self._match(TokenType.EQ):
2162            self._retreat(index)
2163            return self._parse_sequence_properties()
2164
2165        # Transform the key to exp.Dot if it's dotted identifiers wrapped in exp.Column or to exp.Var otherwise
2166        if isinstance(key, exp.Column):
2167            key = key.to_dot() if len(key.parts) > 1 else exp.var(key.name)
2168
2169        value = self._parse_bitwise() or self._parse_var(any_token=True)
2170
2171        # Transform the value to exp.Var if it was parsed as exp.Column(exp.Identifier())
2172        if isinstance(value, exp.Column):
2173            value = exp.var(value.name)
2174
2175        return self.expression(exp.Property, this=key, value=value)
2176
2177    def _parse_stored(self) -> t.Union[exp.FileFormatProperty, exp.StorageHandlerProperty]:
2178        if self._match_text_seq("BY"):
2179            return self.expression(exp.StorageHandlerProperty, this=self._parse_var_or_string())
2180
2181        self._match(TokenType.ALIAS)
2182        input_format = self._parse_string() if self._match_text_seq("INPUTFORMAT") else None
2183        output_format = self._parse_string() if self._match_text_seq("OUTPUTFORMAT") else None
2184
2185        return self.expression(
2186            exp.FileFormatProperty,
2187            this=(
2188                self.expression(
2189                    exp.InputOutputFormat,
2190                    input_format=input_format,
2191                    output_format=output_format,
2192                )
2193                if input_format or output_format
2194                else self._parse_var_or_string() or self._parse_number() or self._parse_id_var()
2195            ),
2196        )
2197
2198    def _parse_unquoted_field(self) -> t.Optional[exp.Expression]:
2199        field = self._parse_field()
2200        if isinstance(field, exp.Identifier) and not field.quoted:
2201            field = exp.var(field)
2202
2203        return field
2204
2205    def _parse_property_assignment(self, exp_class: t.Type[E], **kwargs: t.Any) -> E:
2206        self._match(TokenType.EQ)
2207        self._match(TokenType.ALIAS)
2208
2209        return self.expression(exp_class, this=self._parse_unquoted_field(), **kwargs)
2210
2211    def _parse_properties(self, before: t.Optional[bool] = None) -> t.Optional[exp.Properties]:
2212        properties = []
2213        while True:
2214            if before:
2215                prop = self._parse_property_before()
2216            else:
2217                prop = self._parse_property()
2218            if not prop:
2219                break
2220            for p in ensure_list(prop):
2221                properties.append(p)
2222
2223        if properties:
2224            return self.expression(exp.Properties, expressions=properties)
2225
2226        return None
2227
2228    def _parse_fallback(self, no: bool = False) -> exp.FallbackProperty:
2229        return self.expression(
2230            exp.FallbackProperty, no=no, protection=self._match_text_seq("PROTECTION")
2231        )
2232
2233    def _parse_security(self) -> t.Optional[exp.SecurityProperty]:
2234        if self._match_texts(("DEFINER", "INVOKER")):
2235            security_specifier = self._prev.text.upper()
2236            return self.expression(exp.SecurityProperty, this=security_specifier)
2237        return None
2238
2239    def _parse_settings_property(self) -> exp.SettingsProperty:
2240        return self.expression(
2241            exp.SettingsProperty, expressions=self._parse_csv(self._parse_assignment)
2242        )
2243
2244    def _parse_volatile_property(self) -> exp.VolatileProperty | exp.StabilityProperty:
2245        if self._index >= 2:
2246            pre_volatile_token = self._tokens[self._index - 2]
2247        else:
2248            pre_volatile_token = None
2249
2250        if pre_volatile_token and pre_volatile_token.token_type in self.PRE_VOLATILE_TOKENS:
2251            return exp.VolatileProperty()
2252
2253        return self.expression(exp.StabilityProperty, this=exp.Literal.string("VOLATILE"))
2254
2255    def _parse_retention_period(self) -> exp.Var:
2256        # Parse TSQL's HISTORY_RETENTION_PERIOD: {INFINITE | <number> DAY | DAYS | MONTH ...}
2257        number = self._parse_number()
2258        number_str = f"{number} " if number else ""
2259        unit = self._parse_var(any_token=True)
2260        return exp.var(f"{number_str}{unit}")
2261
2262    def _parse_system_versioning_property(
2263        self, with_: bool = False
2264    ) -> exp.WithSystemVersioningProperty:
2265        self._match(TokenType.EQ)
2266        prop = self.expression(
2267            exp.WithSystemVersioningProperty,
2268            **{  # type: ignore
2269                "on": True,
2270                "with": with_,
2271            },
2272        )
2273
2274        if self._match_text_seq("OFF"):
2275            prop.set("on", False)
2276            return prop
2277
2278        self._match(TokenType.ON)
2279        if self._match(TokenType.L_PAREN):
2280            while self._curr and not self._match(TokenType.R_PAREN):
2281                if self._match_text_seq("HISTORY_TABLE", "="):
2282                    prop.set("this", self._parse_table_parts())
2283                elif self._match_text_seq("DATA_CONSISTENCY_CHECK", "="):
2284                    prop.set("data_consistency", self._advance_any() and self._prev.text.upper())
2285                elif self._match_text_seq("HISTORY_RETENTION_PERIOD", "="):
2286                    prop.set("retention_period", self._parse_retention_period())
2287
2288                self._match(TokenType.COMMA)
2289
2290        return prop
2291
2292    def _parse_data_deletion_property(self) -> exp.DataDeletionProperty:
2293        self._match(TokenType.EQ)
2294        on = self._match_text_seq("ON") or not self._match_text_seq("OFF")
2295        prop = self.expression(exp.DataDeletionProperty, on=on)
2296
2297        if self._match(TokenType.L_PAREN):
2298            while self._curr and not self._match(TokenType.R_PAREN):
2299                if self._match_text_seq("FILTER_COLUMN", "="):
2300                    prop.set("filter_column", self._parse_column())
2301                elif self._match_text_seq("RETENTION_PERIOD", "="):
2302                    prop.set("retention_period", self._parse_retention_period())
2303
2304                self._match(TokenType.COMMA)
2305
2306        return prop
2307
2308    def _parse_distributed_property(self) -> exp.DistributedByProperty:
2309        kind = "HASH"
2310        expressions: t.Optional[t.List[exp.Expression]] = None
2311        if self._match_text_seq("BY", "HASH"):
2312            expressions = self._parse_wrapped_csv(self._parse_id_var)
2313        elif self._match_text_seq("BY", "RANDOM"):
2314            kind = "RANDOM"
2315
2316        # If the BUCKETS keyword is not present, the number of buckets is AUTO
2317        buckets: t.Optional[exp.Expression] = None
2318        if self._match_text_seq("BUCKETS") and not self._match_text_seq("AUTO"):
2319            buckets = self._parse_number()
2320
2321        return self.expression(
2322            exp.DistributedByProperty,
2323            expressions=expressions,
2324            kind=kind,
2325            buckets=buckets,
2326            order=self._parse_order(),
2327        )
2328
2329    def _parse_composite_key_property(self, expr_type: t.Type[E]) -> E:
2330        self._match_text_seq("KEY")
2331        expressions = self._parse_wrapped_id_vars()
2332        return self.expression(expr_type, expressions=expressions)
2333
2334    def _parse_with_property(self) -> t.Optional[exp.Expression] | t.List[exp.Expression]:
2335        if self._match_text_seq("(", "SYSTEM_VERSIONING"):
2336            prop = self._parse_system_versioning_property(with_=True)
2337            self._match_r_paren()
2338            return prop
2339
2340        if self._match(TokenType.L_PAREN, advance=False):
2341            return self._parse_wrapped_properties()
2342
2343        if self._match_text_seq("JOURNAL"):
2344            return self._parse_withjournaltable()
2345
2346        if self._match_texts(self.VIEW_ATTRIBUTES):
2347            return self.expression(exp.ViewAttributeProperty, this=self._prev.text.upper())
2348
2349        if self._match_text_seq("DATA"):
2350            return self._parse_withdata(no=False)
2351        elif self._match_text_seq("NO", "DATA"):
2352            return self._parse_withdata(no=True)
2353
2354        if self._match(TokenType.SERDE_PROPERTIES, advance=False):
2355            return self._parse_serde_properties(with_=True)
2356
2357        if self._match(TokenType.SCHEMA):
2358            return self.expression(
2359                exp.WithSchemaBindingProperty,
2360                this=self._parse_var_from_options(self.SCHEMA_BINDING_OPTIONS),
2361            )
2362
2363        if self._match_texts(self.PROCEDURE_OPTIONS, advance=False):
2364            return self.expression(
2365                exp.WithProcedureOptions, expressions=self._parse_csv(self._parse_procedure_option)
2366            )
2367
2368        if not self._next:
2369            return None
2370
2371        return self._parse_withisolatedloading()
2372
2373    def _parse_procedure_option(self) -> exp.Expression | None:
2374        if self._match_text_seq("EXECUTE", "AS"):
2375            return self.expression(
2376                exp.ExecuteAsProperty,
2377                this=self._parse_var_from_options(self.EXECUTE_AS_OPTIONS, raise_unmatched=False)
2378                or self._parse_string(),
2379            )
2380
2381        return self._parse_var_from_options(self.PROCEDURE_OPTIONS)
2382
2383    # https://dev.mysql.com/doc/refman/8.0/en/create-view.html
2384    def _parse_definer(self) -> t.Optional[exp.DefinerProperty]:
2385        self._match(TokenType.EQ)
2386
2387        user = self._parse_id_var()
2388        self._match(TokenType.PARAMETER)
2389        host = self._parse_id_var() or (self._match(TokenType.MOD) and self._prev.text)
2390
2391        if not user or not host:
2392            return None
2393
2394        return exp.DefinerProperty(this=f"{user}@{host}")
2395
2396    def _parse_withjournaltable(self) -> exp.WithJournalTableProperty:
2397        self._match(TokenType.TABLE)
2398        self._match(TokenType.EQ)
2399        return self.expression(exp.WithJournalTableProperty, this=self._parse_table_parts())
2400
2401    def _parse_log(self, no: bool = False) -> exp.LogProperty:
2402        return self.expression(exp.LogProperty, no=no)
2403
2404    def _parse_journal(self, **kwargs) -> exp.JournalProperty:
2405        return self.expression(exp.JournalProperty, **kwargs)
2406
2407    def _parse_checksum(self) -> exp.ChecksumProperty:
2408        self._match(TokenType.EQ)
2409
2410        on = None
2411        if self._match(TokenType.ON):
2412            on = True
2413        elif self._match_text_seq("OFF"):
2414            on = False
2415
2416        return self.expression(exp.ChecksumProperty, on=on, default=self._match(TokenType.DEFAULT))
2417
2418    def _parse_cluster(self, wrapped: bool = False) -> exp.Cluster:
2419        return self.expression(
2420            exp.Cluster,
2421            expressions=(
2422                self._parse_wrapped_csv(self._parse_ordered)
2423                if wrapped
2424                else self._parse_csv(self._parse_ordered)
2425            ),
2426        )
2427
2428    def _parse_clustered_by(self) -> exp.ClusteredByProperty:
2429        self._match_text_seq("BY")
2430
2431        self._match_l_paren()
2432        expressions = self._parse_csv(self._parse_column)
2433        self._match_r_paren()
2434
2435        if self._match_text_seq("SORTED", "BY"):
2436            self._match_l_paren()
2437            sorted_by = self._parse_csv(self._parse_ordered)
2438            self._match_r_paren()
2439        else:
2440            sorted_by = None
2441
2442        self._match(TokenType.INTO)
2443        buckets = self._parse_number()
2444        self._match_text_seq("BUCKETS")
2445
2446        return self.expression(
2447            exp.ClusteredByProperty,
2448            expressions=expressions,
2449            sorted_by=sorted_by,
2450            buckets=buckets,
2451        )
2452
2453    def _parse_copy_property(self) -> t.Optional[exp.CopyGrantsProperty]:
2454        if not self._match_text_seq("GRANTS"):
2455            self._retreat(self._index - 1)
2456            return None
2457
2458        return self.expression(exp.CopyGrantsProperty)
2459
2460    def _parse_freespace(self) -> exp.FreespaceProperty:
2461        self._match(TokenType.EQ)
2462        return self.expression(
2463            exp.FreespaceProperty, this=self._parse_number(), percent=self._match(TokenType.PERCENT)
2464        )
2465
2466    def _parse_mergeblockratio(
2467        self, no: bool = False, default: bool = False
2468    ) -> exp.MergeBlockRatioProperty:
2469        if self._match(TokenType.EQ):
2470            return self.expression(
2471                exp.MergeBlockRatioProperty,
2472                this=self._parse_number(),
2473                percent=self._match(TokenType.PERCENT),
2474            )
2475
2476        return self.expression(exp.MergeBlockRatioProperty, no=no, default=default)
2477
2478    def _parse_datablocksize(
2479        self,
2480        default: t.Optional[bool] = None,
2481        minimum: t.Optional[bool] = None,
2482        maximum: t.Optional[bool] = None,
2483    ) -> exp.DataBlocksizeProperty:
2484        self._match(TokenType.EQ)
2485        size = self._parse_number()
2486
2487        units = None
2488        if self._match_texts(("BYTES", "KBYTES", "KILOBYTES")):
2489            units = self._prev.text
2490
2491        return self.expression(
2492            exp.DataBlocksizeProperty,
2493            size=size,
2494            units=units,
2495            default=default,
2496            minimum=minimum,
2497            maximum=maximum,
2498        )
2499
2500    def _parse_blockcompression(self) -> exp.BlockCompressionProperty:
2501        self._match(TokenType.EQ)
2502        always = self._match_text_seq("ALWAYS")
2503        manual = self._match_text_seq("MANUAL")
2504        never = self._match_text_seq("NEVER")
2505        default = self._match_text_seq("DEFAULT")
2506
2507        autotemp = None
2508        if self._match_text_seq("AUTOTEMP"):
2509            autotemp = self._parse_schema()
2510
2511        return self.expression(
2512            exp.BlockCompressionProperty,
2513            always=always,
2514            manual=manual,
2515            never=never,
2516            default=default,
2517            autotemp=autotemp,
2518        )
2519
2520    def _parse_withisolatedloading(self) -> t.Optional[exp.IsolatedLoadingProperty]:
2521        index = self._index
2522        no = self._match_text_seq("NO")
2523        concurrent = self._match_text_seq("CONCURRENT")
2524
2525        if not self._match_text_seq("ISOLATED", "LOADING"):
2526            self._retreat(index)
2527            return None
2528
2529        target = self._parse_var_from_options(self.ISOLATED_LOADING_OPTIONS, raise_unmatched=False)
2530        return self.expression(
2531            exp.IsolatedLoadingProperty, no=no, concurrent=concurrent, target=target
2532        )
2533
2534    def _parse_locking(self) -> exp.LockingProperty:
2535        if self._match(TokenType.TABLE):
2536            kind = "TABLE"
2537        elif self._match(TokenType.VIEW):
2538            kind = "VIEW"
2539        elif self._match(TokenType.ROW):
2540            kind = "ROW"
2541        elif self._match_text_seq("DATABASE"):
2542            kind = "DATABASE"
2543        else:
2544            kind = None
2545
2546        if kind in ("DATABASE", "TABLE", "VIEW"):
2547            this = self._parse_table_parts()
2548        else:
2549            this = None
2550
2551        if self._match(TokenType.FOR):
2552            for_or_in = "FOR"
2553        elif self._match(TokenType.IN):
2554            for_or_in = "IN"
2555        else:
2556            for_or_in = None
2557
2558        if self._match_text_seq("ACCESS"):
2559            lock_type = "ACCESS"
2560        elif self._match_texts(("EXCL", "EXCLUSIVE")):
2561            lock_type = "EXCLUSIVE"
2562        elif self._match_text_seq("SHARE"):
2563            lock_type = "SHARE"
2564        elif self._match_text_seq("READ"):
2565            lock_type = "READ"
2566        elif self._match_text_seq("WRITE"):
2567            lock_type = "WRITE"
2568        elif self._match_text_seq("CHECKSUM"):
2569            lock_type = "CHECKSUM"
2570        else:
2571            lock_type = None
2572
2573        override = self._match_text_seq("OVERRIDE")
2574
2575        return self.expression(
2576            exp.LockingProperty,
2577            this=this,
2578            kind=kind,
2579            for_or_in=for_or_in,
2580            lock_type=lock_type,
2581            override=override,
2582        )
2583
2584    def _parse_partition_by(self) -> t.List[exp.Expression]:
2585        if self._match(TokenType.PARTITION_BY):
2586            return self._parse_csv(self._parse_assignment)
2587        return []
2588
2589    def _parse_partition_bound_spec(self) -> exp.PartitionBoundSpec:
2590        def _parse_partition_bound_expr() -> t.Optional[exp.Expression]:
2591            if self._match_text_seq("MINVALUE"):
2592                return exp.var("MINVALUE")
2593            if self._match_text_seq("MAXVALUE"):
2594                return exp.var("MAXVALUE")
2595            return self._parse_bitwise()
2596
2597        this: t.Optional[exp.Expression | t.List[exp.Expression]] = None
2598        expression = None
2599        from_expressions = None
2600        to_expressions = None
2601
2602        if self._match(TokenType.IN):
2603            this = self._parse_wrapped_csv(self._parse_bitwise)
2604        elif self._match(TokenType.FROM):
2605            from_expressions = self._parse_wrapped_csv(_parse_partition_bound_expr)
2606            self._match_text_seq("TO")
2607            to_expressions = self._parse_wrapped_csv(_parse_partition_bound_expr)
2608        elif self._match_text_seq("WITH", "(", "MODULUS"):
2609            this = self._parse_number()
2610            self._match_text_seq(",", "REMAINDER")
2611            expression = self._parse_number()
2612            self._match_r_paren()
2613        else:
2614            self.raise_error("Failed to parse partition bound spec.")
2615
2616        return self.expression(
2617            exp.PartitionBoundSpec,
2618            this=this,
2619            expression=expression,
2620            from_expressions=from_expressions,
2621            to_expressions=to_expressions,
2622        )
2623
2624    # https://www.postgresql.org/docs/current/sql-createtable.html
2625    def _parse_partitioned_of(self) -> t.Optional[exp.PartitionedOfProperty]:
2626        if not self._match_text_seq("OF"):
2627            self._retreat(self._index - 1)
2628            return None
2629
2630        this = self._parse_table(schema=True)
2631
2632        if self._match(TokenType.DEFAULT):
2633            expression: exp.Var | exp.PartitionBoundSpec = exp.var("DEFAULT")
2634        elif self._match_text_seq("FOR", "VALUES"):
2635            expression = self._parse_partition_bound_spec()
2636        else:
2637            self.raise_error("Expecting either DEFAULT or FOR VALUES clause.")
2638
2639        return self.expression(exp.PartitionedOfProperty, this=this, expression=expression)
2640
2641    def _parse_partitioned_by(self) -> exp.PartitionedByProperty:
2642        self._match(TokenType.EQ)
2643        return self.expression(
2644            exp.PartitionedByProperty,
2645            this=self._parse_schema() or self._parse_bracket(self._parse_field()),
2646        )
2647
2648    def _parse_withdata(self, no: bool = False) -> exp.WithDataProperty:
2649        if self._match_text_seq("AND", "STATISTICS"):
2650            statistics = True
2651        elif self._match_text_seq("AND", "NO", "STATISTICS"):
2652            statistics = False
2653        else:
2654            statistics = None
2655
2656        return self.expression(exp.WithDataProperty, no=no, statistics=statistics)
2657
2658    def _parse_contains_property(self) -> t.Optional[exp.SqlReadWriteProperty]:
2659        if self._match_text_seq("SQL"):
2660            return self.expression(exp.SqlReadWriteProperty, this="CONTAINS SQL")
2661        return None
2662
2663    def _parse_modifies_property(self) -> t.Optional[exp.SqlReadWriteProperty]:
2664        if self._match_text_seq("SQL", "DATA"):
2665            return self.expression(exp.SqlReadWriteProperty, this="MODIFIES SQL DATA")
2666        return None
2667
2668    def _parse_no_property(self) -> t.Optional[exp.Expression]:
2669        if self._match_text_seq("PRIMARY", "INDEX"):
2670            return exp.NoPrimaryIndexProperty()
2671        if self._match_text_seq("SQL"):
2672            return self.expression(exp.SqlReadWriteProperty, this="NO SQL")
2673        return None
2674
2675    def _parse_on_property(self) -> t.Optional[exp.Expression]:
2676        if self._match_text_seq("COMMIT", "PRESERVE", "ROWS"):
2677            return exp.OnCommitProperty()
2678        if self._match_text_seq("COMMIT", "DELETE", "ROWS"):
2679            return exp.OnCommitProperty(delete=True)
2680        return self.expression(exp.OnProperty, this=self._parse_schema(self._parse_id_var()))
2681
2682    def _parse_reads_property(self) -> t.Optional[exp.SqlReadWriteProperty]:
2683        if self._match_text_seq("SQL", "DATA"):
2684            return self.expression(exp.SqlReadWriteProperty, this="READS SQL DATA")
2685        return None
2686
2687    def _parse_distkey(self) -> exp.DistKeyProperty:
2688        return self.expression(exp.DistKeyProperty, this=self._parse_wrapped(self._parse_id_var))
2689
2690    def _parse_create_like(self) -> t.Optional[exp.LikeProperty]:
2691        table = self._parse_table(schema=True)
2692
2693        options = []
2694        while self._match_texts(("INCLUDING", "EXCLUDING")):
2695            this = self._prev.text.upper()
2696
2697            id_var = self._parse_id_var()
2698            if not id_var:
2699                return None
2700
2701            options.append(
2702                self.expression(exp.Property, this=this, value=exp.var(id_var.this.upper()))
2703            )
2704
2705        return self.expression(exp.LikeProperty, this=table, expressions=options)
2706
2707    def _parse_sortkey(self, compound: bool = False) -> exp.SortKeyProperty:
2708        return self.expression(
2709            exp.SortKeyProperty, this=self._parse_wrapped_id_vars(), compound=compound
2710        )
2711
2712    def _parse_character_set(self, default: bool = False) -> exp.CharacterSetProperty:
2713        self._match(TokenType.EQ)
2714        return self.expression(
2715            exp.CharacterSetProperty, this=self._parse_var_or_string(), default=default
2716        )
2717
2718    def _parse_remote_with_connection(self) -> exp.RemoteWithConnectionModelProperty:
2719        self._match_text_seq("WITH", "CONNECTION")
2720        return self.expression(
2721            exp.RemoteWithConnectionModelProperty, this=self._parse_table_parts()
2722        )
2723
2724    def _parse_returns(self) -> exp.ReturnsProperty:
2725        value: t.Optional[exp.Expression]
2726        null = None
2727        is_table = self._match(TokenType.TABLE)
2728
2729        if is_table:
2730            if self._match(TokenType.LT):
2731                value = self.expression(
2732                    exp.Schema,
2733                    this="TABLE",
2734                    expressions=self._parse_csv(self._parse_struct_types),
2735                )
2736                if not self._match(TokenType.GT):
2737                    self.raise_error("Expecting >")
2738            else:
2739                value = self._parse_schema(exp.var("TABLE"))
2740        elif self._match_text_seq("NULL", "ON", "NULL", "INPUT"):
2741            null = True
2742            value = None
2743        else:
2744            value = self._parse_types()
2745
2746        return self.expression(exp.ReturnsProperty, this=value, is_table=is_table, null=null)
2747
2748    def _parse_describe(self) -> exp.Describe:
2749        kind = self._match_set(self.CREATABLES) and self._prev.text
2750        style = self._match_texts(self.DESCRIBE_STYLES) and self._prev.text.upper()
2751        if self._match(TokenType.DOT):
2752            style = None
2753            self._retreat(self._index - 2)
2754
2755        format = self._parse_property() if self._match(TokenType.FORMAT, advance=False) else None
2756
2757        if self._match_set(self.STATEMENT_PARSERS, advance=False):
2758            this = self._parse_statement()
2759        else:
2760            this = self._parse_table(schema=True)
2761
2762        properties = self._parse_properties()
2763        expressions = properties.expressions if properties else None
2764        partition = self._parse_partition()
2765        return self.expression(
2766            exp.Describe,
2767            this=this,
2768            style=style,
2769            kind=kind,
2770            expressions=expressions,
2771            partition=partition,
2772            format=format,
2773        )
2774
2775    def _parse_multitable_inserts(self, comments: t.Optional[t.List[str]]) -> exp.MultitableInserts:
2776        kind = self._prev.text.upper()
2777        expressions = []
2778
2779        def parse_conditional_insert() -> t.Optional[exp.ConditionalInsert]:
2780            if self._match(TokenType.WHEN):
2781                expression = self._parse_disjunction()
2782                self._match(TokenType.THEN)
2783            else:
2784                expression = None
2785
2786            else_ = self._match(TokenType.ELSE)
2787
2788            if not self._match(TokenType.INTO):
2789                return None
2790
2791            return self.expression(
2792                exp.ConditionalInsert,
2793                this=self.expression(
2794                    exp.Insert,
2795                    this=self._parse_table(schema=True),
2796                    expression=self._parse_derived_table_values(),
2797                ),
2798                expression=expression,
2799                else_=else_,
2800            )
2801
2802        expression = parse_conditional_insert()
2803        while expression is not None:
2804            expressions.append(expression)
2805            expression = parse_conditional_insert()
2806
2807        return self.expression(
2808            exp.MultitableInserts,
2809            kind=kind,
2810            comments=comments,
2811            expressions=expressions,
2812            source=self._parse_table(),
2813        )
2814
2815    def _parse_insert(self) -> t.Union[exp.Insert, exp.MultitableInserts]:
2816        comments = []
2817        hint = self._parse_hint()
2818        overwrite = self._match(TokenType.OVERWRITE)
2819        ignore = self._match(TokenType.IGNORE)
2820        local = self._match_text_seq("LOCAL")
2821        alternative = None
2822        is_function = None
2823
2824        if self._match_text_seq("DIRECTORY"):
2825            this: t.Optional[exp.Expression] = self.expression(
2826                exp.Directory,
2827                this=self._parse_var_or_string(),
2828                local=local,
2829                row_format=self._parse_row_format(match_row=True),
2830            )
2831        else:
2832            if self._match_set((TokenType.FIRST, TokenType.ALL)):
2833                comments += ensure_list(self._prev_comments)
2834                return self._parse_multitable_inserts(comments)
2835
2836            if self._match(TokenType.OR):
2837                alternative = self._match_texts(self.INSERT_ALTERNATIVES) and self._prev.text
2838
2839            self._match(TokenType.INTO)
2840            comments += ensure_list(self._prev_comments)
2841            self._match(TokenType.TABLE)
2842            is_function = self._match(TokenType.FUNCTION)
2843
2844            this = (
2845                self._parse_table(schema=True, parse_partition=True)
2846                if not is_function
2847                else self._parse_function()
2848            )
2849            if isinstance(this, exp.Table) and self._match(TokenType.ALIAS, advance=False):
2850                this.set("alias", self._parse_table_alias())
2851
2852        returning = self._parse_returning()
2853
2854        return self.expression(
2855            exp.Insert,
2856            comments=comments,
2857            hint=hint,
2858            is_function=is_function,
2859            this=this,
2860            stored=self._match_text_seq("STORED") and self._parse_stored(),
2861            by_name=self._match_text_seq("BY", "NAME"),
2862            exists=self._parse_exists(),
2863            where=self._match_pair(TokenType.REPLACE, TokenType.WHERE) and self._parse_assignment(),
2864            partition=self._match(TokenType.PARTITION_BY) and self._parse_partitioned_by(),
2865            settings=self._match_text_seq("SETTINGS") and self._parse_settings_property(),
2866            expression=self._parse_derived_table_values() or self._parse_ddl_select(),
2867            conflict=self._parse_on_conflict(),
2868            returning=returning or self._parse_returning(),
2869            overwrite=overwrite,
2870            alternative=alternative,
2871            ignore=ignore,
2872            source=self._match(TokenType.TABLE) and self._parse_table(),
2873        )
2874
2875    def _parse_kill(self) -> exp.Kill:
2876        kind = exp.var(self._prev.text) if self._match_texts(("CONNECTION", "QUERY")) else None
2877
2878        return self.expression(
2879            exp.Kill,
2880            this=self._parse_primary(),
2881            kind=kind,
2882        )
2883
2884    def _parse_on_conflict(self) -> t.Optional[exp.OnConflict]:
2885        conflict = self._match_text_seq("ON", "CONFLICT")
2886        duplicate = self._match_text_seq("ON", "DUPLICATE", "KEY")
2887
2888        if not conflict and not duplicate:
2889            return None
2890
2891        conflict_keys = None
2892        constraint = None
2893
2894        if conflict:
2895            if self._match_text_seq("ON", "CONSTRAINT"):
2896                constraint = self._parse_id_var()
2897            elif self._match(TokenType.L_PAREN):
2898                conflict_keys = self._parse_csv(self._parse_id_var)
2899                self._match_r_paren()
2900
2901        action = self._parse_var_from_options(self.CONFLICT_ACTIONS)
2902        if self._prev.token_type == TokenType.UPDATE:
2903            self._match(TokenType.SET)
2904            expressions = self._parse_csv(self._parse_equality)
2905        else:
2906            expressions = None
2907
2908        return self.expression(
2909            exp.OnConflict,
2910            duplicate=duplicate,
2911            expressions=expressions,
2912            action=action,
2913            conflict_keys=conflict_keys,
2914            constraint=constraint,
2915            where=self._parse_where(),
2916        )
2917
2918    def _parse_returning(self) -> t.Optional[exp.Returning]:
2919        if not self._match(TokenType.RETURNING):
2920            return None
2921        return self.expression(
2922            exp.Returning,
2923            expressions=self._parse_csv(self._parse_expression),
2924            into=self._match(TokenType.INTO) and self._parse_table_part(),
2925        )
2926
2927    def _parse_row(self) -> t.Optional[exp.RowFormatSerdeProperty | exp.RowFormatDelimitedProperty]:
2928        if not self._match(TokenType.FORMAT):
2929            return None
2930        return self._parse_row_format()
2931
2932    def _parse_serde_properties(self, with_: bool = False) -> t.Optional[exp.SerdeProperties]:
2933        index = self._index
2934        with_ = with_ or self._match_text_seq("WITH")
2935
2936        if not self._match(TokenType.SERDE_PROPERTIES):
2937            self._retreat(index)
2938            return None
2939        return self.expression(
2940            exp.SerdeProperties,
2941            **{  # type: ignore
2942                "expressions": self._parse_wrapped_properties(),
2943                "with": with_,
2944            },
2945        )
2946
2947    def _parse_row_format(
2948        self, match_row: bool = False
2949    ) -> t.Optional[exp.RowFormatSerdeProperty | exp.RowFormatDelimitedProperty]:
2950        if match_row and not self._match_pair(TokenType.ROW, TokenType.FORMAT):
2951            return None
2952
2953        if self._match_text_seq("SERDE"):
2954            this = self._parse_string()
2955
2956            serde_properties = self._parse_serde_properties()
2957
2958            return self.expression(
2959                exp.RowFormatSerdeProperty, this=this, serde_properties=serde_properties
2960            )
2961
2962        self._match_text_seq("DELIMITED")
2963
2964        kwargs = {}
2965
2966        if self._match_text_seq("FIELDS", "TERMINATED", "BY"):
2967            kwargs["fields"] = self._parse_string()
2968            if self._match_text_seq("ESCAPED", "BY"):
2969                kwargs["escaped"] = self._parse_string()
2970        if self._match_text_seq("COLLECTION", "ITEMS", "TERMINATED", "BY"):
2971            kwargs["collection_items"] = self._parse_string()
2972        if self._match_text_seq("MAP", "KEYS", "TERMINATED", "BY"):
2973            kwargs["map_keys"] = self._parse_string()
2974        if self._match_text_seq("LINES", "TERMINATED", "BY"):
2975            kwargs["lines"] = self._parse_string()
2976        if self._match_text_seq("NULL", "DEFINED", "AS"):
2977            kwargs["null"] = self._parse_string()
2978
2979        return self.expression(exp.RowFormatDelimitedProperty, **kwargs)  # type: ignore
2980
2981    def _parse_load(self) -> exp.LoadData | exp.Command:
2982        if self._match_text_seq("DATA"):
2983            local = self._match_text_seq("LOCAL")
2984            self._match_text_seq("INPATH")
2985            inpath = self._parse_string()
2986            overwrite = self._match(TokenType.OVERWRITE)
2987            self._match_pair(TokenType.INTO, TokenType.TABLE)
2988
2989            return self.expression(
2990                exp.LoadData,
2991                this=self._parse_table(schema=True),
2992                local=local,
2993                overwrite=overwrite,
2994                inpath=inpath,
2995                partition=self._parse_partition(),
2996                input_format=self._match_text_seq("INPUTFORMAT") and self._parse_string(),
2997                serde=self._match_text_seq("SERDE") and self._parse_string(),
2998            )
2999        return self._parse_as_command(self._prev)
3000
3001    def _parse_delete(self) -> exp.Delete:
3002        # This handles MySQL's "Multiple-Table Syntax"
3003        # https://dev.mysql.com/doc/refman/8.0/en/delete.html
3004        tables = None
3005        if not self._match(TokenType.FROM, advance=False):
3006            tables = self._parse_csv(self._parse_table) or None
3007
3008        returning = self._parse_returning()
3009
3010        return self.expression(
3011            exp.Delete,
3012            tables=tables,
3013            this=self._match(TokenType.FROM) and self._parse_table(joins=True),
3014            using=self._match(TokenType.USING) and self._parse_table(joins=True),
3015            cluster=self._match(TokenType.ON) and self._parse_on_property(),
3016            where=self._parse_where(),
3017            returning=returning or self._parse_returning(),
3018            limit=self._parse_limit(),
3019        )
3020
3021    def _parse_update(self) -> exp.Update:
3022        this = self._parse_table(joins=True, alias_tokens=self.UPDATE_ALIAS_TOKENS)
3023        expressions = self._match(TokenType.SET) and self._parse_csv(self._parse_equality)
3024        returning = self._parse_returning()
3025        return self.expression(
3026            exp.Update,
3027            **{  # type: ignore
3028                "this": this,
3029                "expressions": expressions,
3030                "from": self._parse_from(joins=True),
3031                "where": self._parse_where(),
3032                "returning": returning or self._parse_returning(),
3033                "order": self._parse_order(),
3034                "limit": self._parse_limit(),
3035            },
3036        )
3037
3038    def _parse_use(self) -> exp.Use:
3039        return self.expression(
3040            exp.Use,
3041            kind=self._parse_var_from_options(self.USABLES, raise_unmatched=False),
3042            this=self._parse_table(schema=False),
3043        )
3044
3045    def _parse_uncache(self) -> exp.Uncache:
3046        if not self._match(TokenType.TABLE):
3047            self.raise_error("Expecting TABLE after UNCACHE")
3048
3049        return self.expression(
3050            exp.Uncache, exists=self._parse_exists(), this=self._parse_table(schema=True)
3051        )
3052
3053    def _parse_cache(self) -> exp.Cache:
3054        lazy = self._match_text_seq("LAZY")
3055        self._match(TokenType.TABLE)
3056        table = self._parse_table(schema=True)
3057
3058        options = []
3059        if self._match_text_seq("OPTIONS"):
3060            self._match_l_paren()
3061            k = self._parse_string()
3062            self._match(TokenType.EQ)
3063            v = self._parse_string()
3064            options = [k, v]
3065            self._match_r_paren()
3066
3067        self._match(TokenType.ALIAS)
3068        return self.expression(
3069            exp.Cache,
3070            this=table,
3071            lazy=lazy,
3072            options=options,
3073            expression=self._parse_select(nested=True),
3074        )
3075
3076    def _parse_partition(self) -> t.Optional[exp.Partition]:
3077        if not self._match_texts(self.PARTITION_KEYWORDS):
3078            return None
3079
3080        return self.expression(
3081            exp.Partition,
3082            subpartition=self._prev.text.upper() == "SUBPARTITION",
3083            expressions=self._parse_wrapped_csv(self._parse_assignment),
3084        )
3085
3086    def _parse_value(self, values: bool = True) -> t.Optional[exp.Tuple]:
3087        def _parse_value_expression() -> t.Optional[exp.Expression]:
3088            if self.dialect.SUPPORTS_VALUES_DEFAULT and self._match(TokenType.DEFAULT):
3089                return exp.var(self._prev.text.upper())
3090            return self._parse_expression()
3091
3092        if self._match(TokenType.L_PAREN):
3093            expressions = self._parse_csv(_parse_value_expression)
3094            self._match_r_paren()
3095            return self.expression(exp.Tuple, expressions=expressions)
3096
3097        # In some dialects we can have VALUES 1, 2 which results in 1 column & 2 rows.
3098        expression = self._parse_expression()
3099        if expression:
3100            return self.expression(exp.Tuple, expressions=[expression])
3101        return None
3102
3103    def _parse_projections(self) -> t.List[exp.Expression]:
3104        return self._parse_expressions()
3105
3106    def _parse_wrapped_select(self, table: bool = False) -> t.Optional[exp.Expression]:
3107        if self._match_set((TokenType.PIVOT, TokenType.UNPIVOT)):
3108            this: t.Optional[exp.Expression] = self._parse_simplified_pivot(
3109                is_unpivot=self._prev.token_type == TokenType.UNPIVOT
3110            )
3111        elif self._match(TokenType.FROM):
3112            from_ = self._parse_from(skip_from_token=True)
3113            # Support parentheses for duckdb FROM-first syntax
3114            select = self._parse_select()
3115            if select:
3116                select.set("from", from_)
3117                this = select
3118            else:
3119                this = exp.select("*").from_(t.cast(exp.From, from_))
3120        else:
3121            this = (
3122                self._parse_table()
3123                if table
3124                else self._parse_select(nested=True, parse_set_operation=False)
3125            )
3126
3127            # Transform exp.Values into a exp.Table to pass through parse_query_modifiers
3128            # in case a modifier (e.g. join) is following
3129            if table and isinstance(this, exp.Values) and this.alias:
3130                alias = this.args["alias"].pop()
3131                this = exp.Table(this=this, alias=alias)
3132
3133            this = self._parse_query_modifiers(self._parse_set_operations(this))
3134
3135        return this
3136
3137    def _parse_select(
3138        self,
3139        nested: bool = False,
3140        table: bool = False,
3141        parse_subquery_alias: bool = True,
3142        parse_set_operation: bool = True,
3143    ) -> t.Optional[exp.Expression]:
3144        cte = self._parse_with()
3145
3146        if cte:
3147            this = self._parse_statement()
3148
3149            if not this:
3150                self.raise_error("Failed to parse any statement following CTE")
3151                return cte
3152
3153            if "with" in this.arg_types:
3154                this.set("with", cte)
3155            else:
3156                self.raise_error(f"{this.key} does not support CTE")
3157                this = cte
3158
3159            return this
3160
3161        # duckdb supports leading with FROM x
3162        from_ = self._parse_from() if self._match(TokenType.FROM, advance=False) else None
3163
3164        if self._match(TokenType.SELECT):
3165            comments = self._prev_comments
3166
3167            hint = self._parse_hint()
3168
3169            if self._next and not self._next.token_type == TokenType.DOT:
3170                all_ = self._match(TokenType.ALL)
3171                distinct = self._match_set(self.DISTINCT_TOKENS)
3172            else:
3173                all_, distinct = None, None
3174
3175            kind = (
3176                self._match(TokenType.ALIAS)
3177                and self._match_texts(("STRUCT", "VALUE"))
3178                and self._prev.text.upper()
3179            )
3180
3181            if distinct:
3182                distinct = self.expression(
3183                    exp.Distinct,
3184                    on=self._parse_value(values=False) if self._match(TokenType.ON) else None,
3185                )
3186
3187            if all_ and distinct:
3188                self.raise_error("Cannot specify both ALL and DISTINCT after SELECT")
3189
3190            operation_modifiers = []
3191            while self._curr and self._match_texts(self.OPERATION_MODIFIERS):
3192                operation_modifiers.append(exp.var(self._prev.text.upper()))
3193
3194            limit = self._parse_limit(top=True)
3195            projections = self._parse_projections()
3196
3197            this = self.expression(
3198                exp.Select,
3199                kind=kind,
3200                hint=hint,
3201                distinct=distinct,
3202                expressions=projections,
3203                limit=limit,
3204                operation_modifiers=operation_modifiers or None,
3205            )
3206            this.comments = comments
3207
3208            into = self._parse_into()
3209            if into:
3210                this.set("into", into)
3211
3212            if not from_:
3213                from_ = self._parse_from()
3214
3215            if from_:
3216                this.set("from", from_)
3217
3218            this = self._parse_query_modifiers(this)
3219        elif (table or nested) and self._match(TokenType.L_PAREN):
3220            this = self._parse_wrapped_select(table=table)
3221
3222            # We return early here so that the UNION isn't attached to the subquery by the
3223            # following call to _parse_set_operations, but instead becomes the parent node
3224            self._match_r_paren()
3225            return self._parse_subquery(this, parse_alias=parse_subquery_alias)
3226        elif self._match(TokenType.VALUES, advance=False):
3227            this = self._parse_derived_table_values()
3228        elif from_:
3229            this = exp.select("*").from_(from_.this, copy=False)
3230        elif self._match(TokenType.SUMMARIZE):
3231            table = self._match(TokenType.TABLE)
3232            this = self._parse_select() or self._parse_string() or self._parse_table()
3233            return self.expression(exp.Summarize, this=this, table=table)
3234        elif self._match(TokenType.DESCRIBE):
3235            this = self._parse_describe()
3236        elif self._match_text_seq("STREAM"):
3237            this = self._parse_function()
3238            if this:
3239                this = self.expression(exp.Stream, this=this)
3240            else:
3241                self._retreat(self._index - 1)
3242        else:
3243            this = None
3244
3245        return self._parse_set_operations(this) if parse_set_operation else this
3246
3247    def _parse_recursive_with_search(self) -> t.Optional[exp.RecursiveWithSearch]:
3248        self._match_text_seq("SEARCH")
3249
3250        kind = self._match_texts(self.RECURSIVE_CTE_SEARCH_KIND) and self._prev.text.upper()
3251
3252        if not kind:
3253            return None
3254
3255        self._match_text_seq("FIRST", "BY")
3256
3257        return self.expression(
3258            exp.RecursiveWithSearch,
3259            kind=kind,
3260            this=self._parse_id_var(),
3261            expression=self._match_text_seq("SET") and self._parse_id_var(),
3262            using=self._match_text_seq("USING") and self._parse_id_var(),
3263        )
3264
3265    def _parse_with(self, skip_with_token: bool = False) -> t.Optional[exp.With]:
3266        if not skip_with_token and not self._match(TokenType.WITH):
3267            return None
3268
3269        comments = self._prev_comments
3270        recursive = self._match(TokenType.RECURSIVE)
3271
3272        last_comments = None
3273        expressions = []
3274        while True:
3275            cte = self._parse_cte()
3276            if isinstance(cte, exp.CTE):
3277                expressions.append(cte)
3278                if last_comments:
3279                    cte.add_comments(last_comments)
3280
3281            if not self._match(TokenType.COMMA) and not self._match(TokenType.WITH):
3282                break
3283            else:
3284                self._match(TokenType.WITH)
3285
3286            last_comments = self._prev_comments
3287
3288        return self.expression(
3289            exp.With,
3290            comments=comments,
3291            expressions=expressions,
3292            recursive=recursive,
3293            search=self._parse_recursive_with_search(),
3294        )
3295
3296    def _parse_cte(self) -> t.Optional[exp.CTE]:
3297        index = self._index
3298
3299        alias = self._parse_table_alias(self.ID_VAR_TOKENS)
3300        if not alias or not alias.this:
3301            self.raise_error("Expected CTE to have alias")
3302
3303        if not self._match(TokenType.ALIAS) and not self.OPTIONAL_ALIAS_TOKEN_CTE:
3304            self._retreat(index)
3305            return None
3306
3307        comments = self._prev_comments
3308
3309        if self._match_text_seq("NOT", "MATERIALIZED"):
3310            materialized = False
3311        elif self._match_text_seq("MATERIALIZED"):
3312            materialized = True
3313        else:
3314            materialized = None
3315
3316        cte = self.expression(
3317            exp.CTE,
3318            this=self._parse_wrapped(self._parse_statement),
3319            alias=alias,
3320            materialized=materialized,
3321            comments=comments,
3322        )
3323
3324        if isinstance(cte.this, exp.Values):
3325            cte.set("this", exp.select("*").from_(exp.alias_(cte.this, "_values", table=True)))
3326
3327        return cte
3328
3329    def _parse_table_alias(
3330        self, alias_tokens: t.Optional[t.Collection[TokenType]] = None
3331    ) -> t.Optional[exp.TableAlias]:
3332        # In some dialects, LIMIT and OFFSET can act as both identifiers and keywords (clauses)
3333        # so this section tries to parse the clause version and if it fails, it treats the token
3334        # as an identifier (alias)
3335        if self._can_parse_limit_or_offset():
3336            return None
3337
3338        any_token = self._match(TokenType.ALIAS)
3339        alias = (
3340            self._parse_id_var(any_token=any_token, tokens=alias_tokens or self.TABLE_ALIAS_TOKENS)
3341            or self._parse_string_as_identifier()
3342        )
3343
3344        index = self._index
3345        if self._match(TokenType.L_PAREN):
3346            columns = self._parse_csv(self._parse_function_parameter)
3347            self._match_r_paren() if columns else self._retreat(index)
3348        else:
3349            columns = None
3350
3351        if not alias and not columns:
3352            return None
3353
3354        table_alias = self.expression(exp.TableAlias, this=alias, columns=columns)
3355
3356        # We bubble up comments from the Identifier to the TableAlias
3357        if isinstance(alias, exp.Identifier):
3358            table_alias.add_comments(alias.pop_comments())
3359
3360        return table_alias
3361
3362    def _parse_subquery(
3363        self, this: t.Optional[exp.Expression], parse_alias: bool = True
3364    ) -> t.Optional[exp.Subquery]:
3365        if not this:
3366            return None
3367
3368        return self.expression(
3369            exp.Subquery,
3370            this=this,
3371            pivots=self._parse_pivots(),
3372            alias=self._parse_table_alias() if parse_alias else None,
3373            sample=self._parse_table_sample(),
3374        )
3375
3376    def _implicit_unnests_to_explicit(self, this: E) -> E:
3377        from sqlglot.optimizer.normalize_identifiers import normalize_identifiers as _norm
3378
3379        refs = {_norm(this.args["from"].this.copy(), dialect=self.dialect).alias_or_name}
3380        for i, join in enumerate(this.args.get("joins") or []):
3381            table = join.this
3382            normalized_table = table.copy()
3383            normalized_table.meta["maybe_column"] = True
3384            normalized_table = _norm(normalized_table, dialect=self.dialect)
3385
3386            if isinstance(table, exp.Table) and not join.args.get("on"):
3387                if normalized_table.parts[0].name in refs:
3388                    table_as_column = table.to_column()
3389                    unnest = exp.Unnest(expressions=[table_as_column])
3390
3391                    # Table.to_column creates a parent Alias node that we want to convert to
3392                    # a TableAlias and attach to the Unnest, so it matches the parser's output
3393                    if isinstance(table.args.get("alias"), exp.TableAlias):
3394                        table_as_column.replace(table_as_column.this)
3395                        exp.alias_(unnest, None, table=[table.args["alias"].this], copy=False)
3396
3397                    table.replace(unnest)
3398
3399            refs.add(normalized_table.alias_or_name)
3400
3401        return this
3402
3403    def _parse_query_modifiers(
3404        self, this: t.Optional[exp.Expression]
3405    ) -> t.Optional[exp.Expression]:
3406        if isinstance(this, self.MODIFIABLES):
3407            for join in self._parse_joins():
3408                this.append("joins", join)
3409            for lateral in iter(self._parse_lateral, None):
3410                this.append("laterals", lateral)
3411
3412            while True:
3413                if self._match_set(self.QUERY_MODIFIER_PARSERS, advance=False):
3414                    parser = self.QUERY_MODIFIER_PARSERS[self._curr.token_type]
3415                    key, expression = parser(self)
3416
3417                    if expression:
3418                        this.set(key, expression)
3419                        if key == "limit":
3420                            offset = expression.args.pop("offset", None)
3421
3422                            if offset:
3423                                offset = exp.Offset(expression=offset)
3424                                this.set("offset", offset)
3425
3426                                limit_by_expressions = expression.expressions
3427                                expression.set("expressions", None)
3428                                offset.set("expressions", limit_by_expressions)
3429                        continue
3430                break
3431
3432        if self.SUPPORTS_IMPLICIT_UNNEST and this and this.args.get("from"):
3433            this = self._implicit_unnests_to_explicit(this)
3434
3435        return this
3436
3437    def _parse_hint_fallback_to_string(self) -> t.Optional[exp.Hint]:
3438        start = self._curr
3439        while self._curr:
3440            self._advance()
3441
3442        end = self._tokens[self._index - 1]
3443        return exp.Hint(expressions=[self._find_sql(start, end)])
3444
3445    def _parse_hint_function_call(self) -> t.Optional[exp.Expression]:
3446        return self._parse_function_call()
3447
3448    def _parse_hint_body(self) -> t.Optional[exp.Hint]:
3449        start_index = self._index
3450        should_fallback_to_string = False
3451
3452        hints = []
3453        try:
3454            for hint in iter(
3455                lambda: self._parse_csv(
3456                    lambda: self._parse_hint_function_call() or self._parse_var(upper=True),
3457                ),
3458                [],
3459            ):
3460                hints.extend(hint)
3461        except ParseError:
3462            should_fallback_to_string = True
3463
3464        if should_fallback_to_string or self._curr:
3465            self._retreat(start_index)
3466            return self._parse_hint_fallback_to_string()
3467
3468        return self.expression(exp.Hint, expressions=hints)
3469
3470    def _parse_hint(self) -> t.Optional[exp.Hint]:
3471        if self._match(TokenType.HINT) and self._prev_comments:
3472            return exp.maybe_parse(self._prev_comments[0], into=exp.Hint, dialect=self.dialect)
3473
3474        return None
3475
3476    def _parse_into(self) -> t.Optional[exp.Into]:
3477        if not self._match(TokenType.INTO):
3478            return None
3479
3480        temp = self._match(TokenType.TEMPORARY)
3481        unlogged = self._match_text_seq("UNLOGGED")
3482        self._match(TokenType.TABLE)
3483
3484        return self.expression(
3485            exp.Into, this=self._parse_table(schema=True), temporary=temp, unlogged=unlogged
3486        )
3487
3488    def _parse_from(
3489        self, joins: bool = False, skip_from_token: bool = False
3490    ) -> t.Optional[exp.From]:
3491        if not skip_from_token and not self._match(TokenType.FROM):
3492            return None
3493
3494        return self.expression(
3495            exp.From, comments=self._prev_comments, this=self._parse_table(joins=joins)
3496        )
3497
3498    def _parse_match_recognize_measure(self) -> exp.MatchRecognizeMeasure:
3499        return self.expression(
3500            exp.MatchRecognizeMeasure,
3501            window_frame=self._match_texts(("FINAL", "RUNNING")) and self._prev.text.upper(),
3502            this=self._parse_expression(),
3503        )
3504
3505    def _parse_match_recognize(self) -> t.Optional[exp.MatchRecognize]:
3506        if not self._match(TokenType.MATCH_RECOGNIZE):
3507            return None
3508
3509        self._match_l_paren()
3510
3511        partition = self._parse_partition_by()
3512        order = self._parse_order()
3513
3514        measures = (
3515            self._parse_csv(self._parse_match_recognize_measure)
3516            if self._match_text_seq("MEASURES")
3517            else None
3518        )
3519
3520        if self._match_text_seq("ONE", "ROW", "PER", "MATCH"):
3521            rows = exp.var("ONE ROW PER MATCH")
3522        elif self._match_text_seq("ALL", "ROWS", "PER", "MATCH"):
3523            text = "ALL ROWS PER MATCH"
3524            if self._match_text_seq("SHOW", "EMPTY", "MATCHES"):
3525                text += " SHOW EMPTY MATCHES"
3526            elif self._match_text_seq("OMIT", "EMPTY", "MATCHES"):
3527                text += " OMIT EMPTY MATCHES"
3528            elif self._match_text_seq("WITH", "UNMATCHED", "ROWS"):
3529                text += " WITH UNMATCHED ROWS"
3530            rows = exp.var(text)
3531        else:
3532            rows = None
3533
3534        if self._match_text_seq("AFTER", "MATCH", "SKIP"):
3535            text = "AFTER MATCH SKIP"
3536            if self._match_text_seq("PAST", "LAST", "ROW"):
3537                text += " PAST LAST ROW"
3538            elif self._match_text_seq("TO", "NEXT", "ROW"):
3539                text += " TO NEXT ROW"
3540            elif self._match_text_seq("TO", "FIRST"):
3541                text += f" TO FIRST {self._advance_any().text}"  # type: ignore
3542            elif self._match_text_seq("TO", "LAST"):
3543                text += f" TO LAST {self._advance_any().text}"  # type: ignore
3544            after = exp.var(text)
3545        else:
3546            after = None
3547
3548        if self._match_text_seq("PATTERN"):
3549            self._match_l_paren()
3550
3551            if not self._curr:
3552                self.raise_error("Expecting )", self._curr)
3553
3554            paren = 1
3555            start = self._curr
3556
3557            while self._curr and paren > 0:
3558                if self._curr.token_type == TokenType.L_PAREN:
3559                    paren += 1
3560                if self._curr.token_type == TokenType.R_PAREN:
3561                    paren -= 1
3562
3563                end = self._prev
3564                self._advance()
3565
3566            if paren > 0:
3567                self.raise_error("Expecting )", self._curr)
3568
3569            pattern = exp.var(self._find_sql(start, end))
3570        else:
3571            pattern = None
3572
3573        define = (
3574            self._parse_csv(self._parse_name_as_expression)
3575            if self._match_text_seq("DEFINE")
3576            else None
3577        )
3578
3579        self._match_r_paren()
3580
3581        return self.expression(
3582            exp.MatchRecognize,
3583            partition_by=partition,
3584            order=order,
3585            measures=measures,
3586            rows=rows,
3587            after=after,
3588            pattern=pattern,
3589            define=define,
3590            alias=self._parse_table_alias(),
3591        )
3592
3593    def _parse_lateral(self) -> t.Optional[exp.Lateral]:
3594        cross_apply = self._match_pair(TokenType.CROSS, TokenType.APPLY)
3595        if not cross_apply and self._match_pair(TokenType.OUTER, TokenType.APPLY):
3596            cross_apply = False
3597
3598        if cross_apply is not None:
3599            this = self._parse_select(table=True)
3600            view = None
3601            outer = None
3602        elif self._match(TokenType.LATERAL):
3603            this = self._parse_select(table=True)
3604            view = self._match(TokenType.VIEW)
3605            outer = self._match(TokenType.OUTER)
3606        else:
3607            return None
3608
3609        if not this:
3610            this = (
3611                self._parse_unnest()
3612                or self._parse_function()
3613                or self._parse_id_var(any_token=False)
3614            )
3615
3616            while self._match(TokenType.DOT):
3617                this = exp.Dot(
3618                    this=this,
3619                    expression=self._parse_function() or self._parse_id_var(any_token=False),
3620                )
3621
3622        ordinality: t.Optional[bool] = None
3623
3624        if view:
3625            table = self._parse_id_var(any_token=False)
3626            columns = self._parse_csv(self._parse_id_var) if self._match(TokenType.ALIAS) else []
3627            table_alias: t.Optional[exp.TableAlias] = self.expression(
3628                exp.TableAlias, this=table, columns=columns
3629            )
3630        elif isinstance(this, (exp.Subquery, exp.Unnest)) and this.alias:
3631            # We move the alias from the lateral's child node to the lateral itself
3632            table_alias = this.args["alias"].pop()
3633        else:
3634            ordinality = self._match_pair(TokenType.WITH, TokenType.ORDINALITY)
3635            table_alias = self._parse_table_alias()
3636
3637        return self.expression(
3638            exp.Lateral,
3639            this=this,
3640            view=view,
3641            outer=outer,
3642            alias=table_alias,
3643            cross_apply=cross_apply,
3644            ordinality=ordinality,
3645        )
3646
3647    def _parse_join_parts(
3648        self,
3649    ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
3650        return (
3651            self._match_set(self.JOIN_METHODS) and self._prev,
3652            self._match_set(self.JOIN_SIDES) and self._prev,
3653            self._match_set(self.JOIN_KINDS) and self._prev,
3654        )
3655
3656    def _parse_using_identifiers(self) -> t.List[exp.Expression]:
3657        def _parse_column_as_identifier() -> t.Optional[exp.Expression]:
3658            this = self._parse_column()
3659            if isinstance(this, exp.Column):
3660                return this.this
3661            return this
3662
3663        return self._parse_wrapped_csv(_parse_column_as_identifier, optional=True)
3664
3665    def _parse_join(
3666        self, skip_join_token: bool = False, parse_bracket: bool = False
3667    ) -> t.Optional[exp.Join]:
3668        if self._match(TokenType.COMMA):
3669            table = self._try_parse(self._parse_table)
3670            if table:
3671                return self.expression(exp.Join, this=table)
3672            return None
3673
3674        index = self._index
3675        method, side, kind = self._parse_join_parts()
3676        hint = self._prev.text if self._match_texts(self.JOIN_HINTS) else None
3677        join = self._match(TokenType.JOIN) or (kind and kind.token_type == TokenType.STRAIGHT_JOIN)
3678
3679        if not skip_join_token and not join:
3680            self._retreat(index)
3681            kind = None
3682            method = None
3683            side = None
3684
3685        outer_apply = self._match_pair(TokenType.OUTER, TokenType.APPLY, False)
3686        cross_apply = self._match_pair(TokenType.CROSS, TokenType.APPLY, False)
3687
3688        if not skip_join_token and not join and not outer_apply and not cross_apply:
3689            return None
3690
3691        kwargs: t.Dict[str, t.Any] = {"this": self._parse_table(parse_bracket=parse_bracket)}
3692        if kind and kind.token_type == TokenType.ARRAY and self._match(TokenType.COMMA):
3693            kwargs["expressions"] = self._parse_csv(
3694                lambda: self._parse_table(parse_bracket=parse_bracket)
3695            )
3696
3697        if method:
3698            kwargs["method"] = method.text
3699        if side:
3700            kwargs["side"] = side.text
3701        if kind:
3702            kwargs["kind"] = kind.text
3703        if hint:
3704            kwargs["hint"] = hint
3705
3706        if self._match(TokenType.MATCH_CONDITION):
3707            kwargs["match_condition"] = self._parse_wrapped(self._parse_comparison)
3708
3709        if self._match(TokenType.ON):
3710            kwargs["on"] = self._parse_assignment()
3711        elif self._match(TokenType.USING):
3712            kwargs["using"] = self._parse_using_identifiers()
3713        elif (
3714            not (outer_apply or cross_apply)
3715            and not isinstance(kwargs["this"], exp.Unnest)
3716            and not (kind and kind.token_type in (TokenType.CROSS, TokenType.ARRAY))
3717        ):
3718            index = self._index
3719            joins: t.Optional[list] = list(self._parse_joins())
3720
3721            if joins and self._match(TokenType.ON):
3722                kwargs["on"] = self._parse_assignment()
3723            elif joins and self._match(TokenType.USING):
3724                kwargs["using"] = self._parse_using_identifiers()
3725            else:
3726                joins = None
3727                self._retreat(index)
3728
3729            kwargs["this"].set("joins", joins if joins else None)
3730
3731        comments = [c for token in (method, side, kind) if token for c in token.comments]
3732        return self.expression(exp.Join, comments=comments, **kwargs)
3733
3734    def _parse_opclass(self) -> t.Optional[exp.Expression]:
3735        this = self._parse_assignment()
3736
3737        if self._match_texts(self.OPCLASS_FOLLOW_KEYWORDS, advance=False):
3738            return this
3739
3740        if not self._match_set(self.OPTYPE_FOLLOW_TOKENS, advance=False):
3741            return self.expression(exp.Opclass, this=this, expression=self._parse_table_parts())
3742
3743        return this
3744
3745    def _parse_index_params(self) -> exp.IndexParameters:
3746        using = self._parse_var(any_token=True) if self._match(TokenType.USING) else None
3747
3748        if self._match(TokenType.L_PAREN, advance=False):
3749            columns = self._parse_wrapped_csv(self._parse_with_operator)
3750        else:
3751            columns = None
3752
3753        include = self._parse_wrapped_id_vars() if self._match_text_seq("INCLUDE") else None
3754        partition_by = self._parse_partition_by()
3755        with_storage = self._match(TokenType.WITH) and self._parse_wrapped_properties()
3756        tablespace = (
3757            self._parse_var(any_token=True)
3758            if self._match_text_seq("USING", "INDEX", "TABLESPACE")
3759            else None
3760        )
3761        where = self._parse_where()
3762
3763        on = self._parse_field() if self._match(TokenType.ON) else None
3764
3765        return self.expression(
3766            exp.IndexParameters,
3767            using=using,
3768            columns=columns,
3769            include=include,
3770            partition_by=partition_by,
3771            where=where,
3772            with_storage=with_storage,
3773            tablespace=tablespace,
3774            on=on,
3775        )
3776
3777    def _parse_index(
3778        self, index: t.Optional[exp.Expression] = None, anonymous: bool = False
3779    ) -> t.Optional[exp.Index]:
3780        if index or anonymous:
3781            unique = None
3782            primary = None
3783            amp = None
3784
3785            self._match(TokenType.ON)
3786            self._match(TokenType.TABLE)  # hive
3787            table = self._parse_table_parts(schema=True)
3788        else:
3789            unique = self._match(TokenType.UNIQUE)
3790            primary = self._match_text_seq("PRIMARY")
3791            amp = self._match_text_seq("AMP")
3792
3793            if not self._match(TokenType.INDEX):
3794                return None
3795
3796            index = self._parse_id_var()
3797            table = None
3798
3799        params = self._parse_index_params()
3800
3801        return self.expression(
3802            exp.Index,
3803            this=index,
3804            table=table,
3805            unique=unique,
3806            primary=primary,
3807            amp=amp,
3808            params=params,
3809        )
3810
3811    def _parse_table_hints(self) -> t.Optional[t.List[exp.Expression]]:
3812        hints: t.List[exp.Expression] = []
3813        if self._match_pair(TokenType.WITH, TokenType.L_PAREN):
3814            # https://learn.microsoft.com/en-us/sql/t-sql/queries/hints-transact-sql-table?view=sql-server-ver16
3815            hints.append(
3816                self.expression(
3817                    exp.WithTableHint,
3818                    expressions=self._parse_csv(
3819                        lambda: self._parse_function() or self._parse_var(any_token=True)
3820                    ),
3821                )
3822            )
3823            self._match_r_paren()
3824        else:
3825            # https://dev.mysql.com/doc/refman/8.0/en/index-hints.html
3826            while self._match_set(self.TABLE_INDEX_HINT_TOKENS):
3827                hint = exp.IndexTableHint(this=self._prev.text.upper())
3828
3829                self._match_set((TokenType.INDEX, TokenType.KEY))
3830                if self._match(TokenType.FOR):
3831                    hint.set("target", self._advance_any() and self._prev.text.upper())
3832
3833                hint.set("expressions", self._parse_wrapped_id_vars())
3834                hints.append(hint)
3835
3836        return hints or None
3837
3838    def _parse_table_part(self, schema: bool = False) -> t.Optional[exp.Expression]:
3839        return (
3840            (not schema and self._parse_function(optional_parens=False))
3841            or self._parse_id_var(any_token=False)
3842            or self._parse_string_as_identifier()
3843            or self._parse_placeholder()
3844        )
3845
3846    def _parse_table_parts(
3847        self, schema: bool = False, is_db_reference: bool = False, wildcard: bool = False
3848    ) -> exp.Table:
3849        catalog = None
3850        db = None
3851        table: t.Optional[exp.Expression | str] = self._parse_table_part(schema=schema)
3852
3853        while self._match(TokenType.DOT):
3854            if catalog:
3855                # This allows nesting the table in arbitrarily many dot expressions if needed
3856                table = self.expression(
3857                    exp.Dot, this=table, expression=self._parse_table_part(schema=schema)
3858                )
3859            else:
3860                catalog = db
3861                db = table
3862                # "" used for tsql FROM a..b case
3863                table = self._parse_table_part(schema=schema) or ""
3864
3865        if (
3866            wildcard
3867            and self._is_connected()
3868            and (isinstance(table, exp.Identifier) or not table)
3869            and self._match(TokenType.STAR)
3870        ):
3871            if isinstance(table, exp.Identifier):
3872                table.args["this"] += "*"
3873            else:
3874                table = exp.Identifier(this="*")
3875
3876        # We bubble up comments from the Identifier to the Table
3877        comments = table.pop_comments() if isinstance(table, exp.Expression) else None
3878
3879        if is_db_reference:
3880            catalog = db
3881            db = table
3882            table = None
3883
3884        if not table and not is_db_reference:
3885            self.raise_error(f"Expected table name but got {self._curr}")
3886        if not db and is_db_reference:
3887            self.raise_error(f"Expected database name but got {self._curr}")
3888
3889        table = self.expression(
3890            exp.Table,
3891            comments=comments,
3892            this=table,
3893            db=db,
3894            catalog=catalog,
3895        )
3896
3897        changes = self._parse_changes()
3898        if changes:
3899            table.set("changes", changes)
3900
3901        at_before = self._parse_historical_data()
3902        if at_before:
3903            table.set("when", at_before)
3904
3905        pivots = self._parse_pivots()
3906        if pivots:
3907            table.set("pivots", pivots)
3908
3909        return table
3910
3911    def _parse_table(
3912        self,
3913        schema: bool = False,
3914        joins: bool = False,
3915        alias_tokens: t.Optional[t.Collection[TokenType]] = None,
3916        parse_bracket: bool = False,
3917        is_db_reference: bool = False,
3918        parse_partition: bool = False,
3919    ) -> t.Optional[exp.Expression]:
3920        lateral = self._parse_lateral()
3921        if lateral:
3922            return lateral
3923
3924        unnest = self._parse_unnest()
3925        if unnest:
3926            return unnest
3927
3928        values = self._parse_derived_table_values()
3929        if values:
3930            return values
3931
3932        subquery = self._parse_select(table=True)
3933        if subquery:
3934            if not subquery.args.get("pivots"):
3935                subquery.set("pivots", self._parse_pivots())
3936            return subquery
3937
3938        bracket = parse_bracket and self._parse_bracket(None)
3939        bracket = self.expression(exp.Table, this=bracket) if bracket else None
3940
3941        rows_from = self._match_text_seq("ROWS", "FROM") and self._parse_wrapped_csv(
3942            self._parse_table
3943        )
3944        rows_from = self.expression(exp.Table, rows_from=rows_from) if rows_from else None
3945
3946        only = self._match(TokenType.ONLY)
3947
3948        this = t.cast(
3949            exp.Expression,
3950            bracket
3951            or rows_from
3952            or self._parse_bracket(
3953                self._parse_table_parts(schema=schema, is_db_reference=is_db_reference)
3954            ),
3955        )
3956
3957        if only:
3958            this.set("only", only)
3959
3960        # Postgres supports a wildcard (table) suffix operator, which is a no-op in this context
3961        self._match_text_seq("*")
3962
3963        parse_partition = parse_partition or self.SUPPORTS_PARTITION_SELECTION
3964        if parse_partition and self._match(TokenType.PARTITION, advance=False):
3965            this.set("partition", self._parse_partition())
3966
3967        if schema:
3968            return self._parse_schema(this=this)
3969
3970        version = self._parse_version()
3971
3972        if version:
3973            this.set("version", version)
3974
3975        if self.dialect.ALIAS_POST_TABLESAMPLE:
3976            this.set("sample", self._parse_table_sample())
3977
3978        alias = self._parse_table_alias(alias_tokens=alias_tokens or self.TABLE_ALIAS_TOKENS)
3979        if alias:
3980            this.set("alias", alias)
3981
3982        if isinstance(this, exp.Table) and self._match_text_seq("AT"):
3983            return self.expression(
3984                exp.AtIndex, this=this.to_column(copy=False), expression=self._parse_id_var()
3985            )
3986
3987        this.set("hints", self._parse_table_hints())
3988
3989        if not this.args.get("pivots"):
3990            this.set("pivots", self._parse_pivots())
3991
3992        if not self.dialect.ALIAS_POST_TABLESAMPLE:
3993            this.set("sample", self._parse_table_sample())
3994
3995        if joins:
3996            for join in self._parse_joins():
3997                this.append("joins", join)
3998
3999        if self._match_pair(TokenType.WITH, TokenType.ORDINALITY):
4000            this.set("ordinality", True)
4001            this.set("alias", self._parse_table_alias())
4002
4003        return this
4004
4005    def _parse_version(self) -> t.Optional[exp.Version]:
4006        if self._match(TokenType.TIMESTAMP_SNAPSHOT):
4007            this = "TIMESTAMP"
4008        elif self._match(TokenType.VERSION_SNAPSHOT):
4009            this = "VERSION"
4010        else:
4011            return None
4012
4013        if self._match_set((TokenType.FROM, TokenType.BETWEEN)):
4014            kind = self._prev.text.upper()
4015            start = self._parse_bitwise()
4016            self._match_texts(("TO", "AND"))
4017            end = self._parse_bitwise()
4018            expression: t.Optional[exp.Expression] = self.expression(
4019                exp.Tuple, expressions=[start, end]
4020            )
4021        elif self._match_text_seq("CONTAINED", "IN"):
4022            kind = "CONTAINED IN"
4023            expression = self.expression(
4024                exp.Tuple, expressions=self._parse_wrapped_csv(self._parse_bitwise)
4025            )
4026        elif self._match(TokenType.ALL):
4027            kind = "ALL"
4028            expression = None
4029        else:
4030            self._match_text_seq("AS", "OF")
4031            kind = "AS OF"
4032            expression = self._parse_type()
4033
4034        return self.expression(exp.Version, this=this, expression=expression, kind=kind)
4035
4036    def _parse_historical_data(self) -> t.Optional[exp.HistoricalData]:
4037        # https://docs.snowflake.com/en/sql-reference/constructs/at-before
4038        index = self._index
4039        historical_data = None
4040        if self._match_texts(self.HISTORICAL_DATA_PREFIX):
4041            this = self._prev.text.upper()
4042            kind = (
4043                self._match(TokenType.L_PAREN)
4044                and self._match_texts(self.HISTORICAL_DATA_KIND)
4045                and self._prev.text.upper()
4046            )
4047            expression = self._match(TokenType.FARROW) and self._parse_bitwise()
4048
4049            if expression:
4050                self._match_r_paren()
4051                historical_data = self.expression(
4052                    exp.HistoricalData, this=this, kind=kind, expression=expression
4053                )
4054            else:
4055                self._retreat(index)
4056
4057        return historical_data
4058
4059    def _parse_changes(self) -> t.Optional[exp.Changes]:
4060        if not self._match_text_seq("CHANGES", "(", "INFORMATION", "=>"):
4061            return None
4062
4063        information = self._parse_var(any_token=True)
4064        self._match_r_paren()
4065
4066        return self.expression(
4067            exp.Changes,
4068            information=information,
4069            at_before=self._parse_historical_data(),
4070            end=self._parse_historical_data(),
4071        )
4072
4073    def _parse_unnest(self, with_alias: bool = True) -> t.Optional[exp.Unnest]:
4074        if not self._match(TokenType.UNNEST):
4075            return None
4076
4077        expressions = self._parse_wrapped_csv(self._parse_equality)
4078        offset = self._match_pair(TokenType.WITH, TokenType.ORDINALITY)
4079
4080        alias = self._parse_table_alias() if with_alias else None
4081
4082        if alias:
4083            if self.dialect.UNNEST_COLUMN_ONLY:
4084                if alias.args.get("columns"):
4085                    self.raise_error("Unexpected extra column alias in unnest.")
4086
4087                alias.set("columns", [alias.this])
4088                alias.set("this", None)
4089
4090            columns = alias.args.get("columns") or []
4091            if offset and len(expressions) < len(columns):
4092                offset = columns.pop()
4093
4094        if not offset and self._match_pair(TokenType.WITH, TokenType.OFFSET):
4095            self._match(TokenType.ALIAS)
4096            offset = self._parse_id_var(
4097                any_token=False, tokens=self.UNNEST_OFFSET_ALIAS_TOKENS
4098            ) or exp.to_identifier("offset")
4099
4100        return self.expression(exp.Unnest, expressions=expressions, alias=alias, offset=offset)
4101
4102    def _parse_derived_table_values(self) -> t.Optional[exp.Values]:
4103        is_derived = self._match_pair(TokenType.L_PAREN, TokenType.VALUES)
4104        if not is_derived and not (
4105            # ClickHouse's `FORMAT Values` is equivalent to `VALUES`
4106            self._match_text_seq("VALUES") or self._match_text_seq("FORMAT", "VALUES")
4107        ):
4108            return None
4109
4110        expressions = self._parse_csv(self._parse_value)
4111        alias = self._parse_table_alias()
4112
4113        if is_derived:
4114            self._match_r_paren()
4115
4116        return self.expression(
4117            exp.Values, expressions=expressions, alias=alias or self._parse_table_alias()
4118        )
4119
4120    def _parse_table_sample(self, as_modifier: bool = False) -> t.Optional[exp.TableSample]:
4121        if not self._match(TokenType.TABLE_SAMPLE) and not (
4122            as_modifier and self._match_text_seq("USING", "SAMPLE")
4123        ):
4124            return None
4125
4126        bucket_numerator = None
4127        bucket_denominator = None
4128        bucket_field = None
4129        percent = None
4130        size = None
4131        seed = None
4132
4133        method = self._parse_var(tokens=(TokenType.ROW,), upper=True)
4134        matched_l_paren = self._match(TokenType.L_PAREN)
4135
4136        if self.TABLESAMPLE_CSV:
4137            num = None
4138            expressions = self._parse_csv(self._parse_primary)
4139        else:
4140            expressions = None
4141            num = (
4142                self._parse_factor()
4143                if self._match(TokenType.NUMBER, advance=False)
4144                else self._parse_primary() or self._parse_placeholder()
4145            )
4146
4147        if self._match_text_seq("BUCKET"):
4148            bucket_numerator = self._parse_number()
4149            self._match_text_seq("OUT", "OF")
4150            bucket_denominator = bucket_denominator = self._parse_number()
4151            self._match(TokenType.ON)
4152            bucket_field = self._parse_field()
4153        elif self._match_set((TokenType.PERCENT, TokenType.MOD)):
4154            percent = num
4155        elif self._match(TokenType.ROWS) or not self.dialect.TABLESAMPLE_SIZE_IS_PERCENT:
4156            size = num
4157        else:
4158            percent = num
4159
4160        if matched_l_paren:
4161            self._match_r_paren()
4162
4163        if self._match(TokenType.L_PAREN):
4164            method = self._parse_var(upper=True)
4165            seed = self._match(TokenType.COMMA) and self._parse_number()
4166            self._match_r_paren()
4167        elif self._match_texts(("SEED", "REPEATABLE")):
4168            seed = self._parse_wrapped(self._parse_number)
4169
4170        if not method and self.DEFAULT_SAMPLING_METHOD:
4171            method = exp.var(self.DEFAULT_SAMPLING_METHOD)
4172
4173        return self.expression(
4174            exp.TableSample,
4175            expressions=expressions,
4176            method=method,
4177            bucket_numerator=bucket_numerator,
4178            bucket_denominator=bucket_denominator,
4179            bucket_field=bucket_field,
4180            percent=percent,
4181            size=size,
4182            seed=seed,
4183        )
4184
4185    def _parse_pivots(self) -> t.Optional[t.List[exp.Pivot]]:
4186        return list(iter(self._parse_pivot, None)) or None
4187
4188    def _parse_joins(self) -> t.Iterator[exp.Join]:
4189        return iter(self._parse_join, None)
4190
4191    def _parse_unpivot_columns(self) -> t.Optional[exp.UnpivotColumns]:
4192        if not self._match(TokenType.INTO):
4193            return None
4194
4195        return self.expression(
4196            exp.UnpivotColumns,
4197            this=self._match_text_seq("NAME") and self._parse_column(),
4198            expressions=self._match_text_seq("VALUE") and self._parse_csv(self._parse_column),
4199        )
4200
4201    # https://duckdb.org/docs/sql/statements/pivot
4202    def _parse_simplified_pivot(self, is_unpivot: t.Optional[bool] = None) -> exp.Pivot:
4203        def _parse_on() -> t.Optional[exp.Expression]:
4204            this = self._parse_bitwise()
4205
4206            if self._match(TokenType.IN):
4207                # PIVOT ... ON col IN (row_val1, row_val2)
4208                return self._parse_in(this)
4209            if self._match(TokenType.ALIAS, advance=False):
4210                # UNPIVOT ... ON (col1, col2, col3) AS row_val
4211                return self._parse_alias(this)
4212
4213            return this
4214
4215        this = self._parse_table()
4216        expressions = self._match(TokenType.ON) and self._parse_csv(_parse_on)
4217        into = self._parse_unpivot_columns()
4218        using = self._match(TokenType.USING) and self._parse_csv(
4219            lambda: self._parse_alias(self._parse_function())
4220        )
4221        group = self._parse_group()
4222
4223        return self.expression(
4224            exp.Pivot,
4225            this=this,
4226            expressions=expressions,
4227            using=using,
4228            group=group,
4229            unpivot=is_unpivot,
4230            into=into,
4231        )
4232
4233    def _parse_pivot_in(self) -> exp.In:
4234        def _parse_aliased_expression() -> t.Optional[exp.Expression]:
4235            this = self._parse_select_or_expression()
4236
4237            self._match(TokenType.ALIAS)
4238            alias = self._parse_bitwise()
4239            if alias:
4240                if isinstance(alias, exp.Column) and not alias.db:
4241                    alias = alias.this
4242                return self.expression(exp.PivotAlias, this=this, alias=alias)
4243
4244            return this
4245
4246        value = self._parse_column()
4247
4248        if not self._match_pair(TokenType.IN, TokenType.L_PAREN):
4249            self.raise_error("Expecting IN (")
4250
4251        if self._match(TokenType.ANY):
4252            exprs: t.List[exp.Expression] = ensure_list(exp.PivotAny(this=self._parse_order()))
4253        else:
4254            exprs = self._parse_csv(_parse_aliased_expression)
4255
4256        self._match_r_paren()
4257        return self.expression(exp.In, this=value, expressions=exprs)
4258
4259    def _parse_pivot(self) -> t.Optional[exp.Pivot]:
4260        index = self._index
4261        include_nulls = None
4262
4263        if self._match(TokenType.PIVOT):
4264            unpivot = False
4265        elif self._match(TokenType.UNPIVOT):
4266            unpivot = True
4267
4268            # https://docs.databricks.com/en/sql/language-manual/sql-ref-syntax-qry-select-unpivot.html#syntax
4269            if self._match_text_seq("INCLUDE", "NULLS"):
4270                include_nulls = True
4271            elif self._match_text_seq("EXCLUDE", "NULLS"):
4272                include_nulls = False
4273        else:
4274            return None
4275
4276        expressions = []
4277
4278        if not self._match(TokenType.L_PAREN):
4279            self._retreat(index)
4280            return None
4281
4282        if unpivot:
4283            expressions = self._parse_csv(self._parse_column)
4284        else:
4285            expressions = self._parse_csv(lambda: self._parse_alias(self._parse_function()))
4286
4287        if not expressions:
4288            self.raise_error("Failed to parse PIVOT's aggregation list")
4289
4290        if not self._match(TokenType.FOR):
4291            self.raise_error("Expecting FOR")
4292
4293        fields = []
4294        while True:
4295            field = self._try_parse(self._parse_pivot_in)
4296            if not field:
4297                break
4298            fields.append(field)
4299
4300        default_on_null = self._match_text_seq("DEFAULT", "ON", "NULL") and self._parse_wrapped(
4301            self._parse_bitwise
4302        )
4303
4304        group = self._parse_group()
4305
4306        self._match_r_paren()
4307
4308        pivot = self.expression(
4309            exp.Pivot,
4310            expressions=expressions,
4311            fields=fields,
4312            unpivot=unpivot,
4313            include_nulls=include_nulls,
4314            default_on_null=default_on_null,
4315            group=group,
4316        )
4317
4318        if not self._match_set((TokenType.PIVOT, TokenType.UNPIVOT), advance=False):
4319            pivot.set("alias", self._parse_table_alias())
4320
4321        if not unpivot:
4322            names = self._pivot_column_names(t.cast(t.List[exp.Expression], expressions))
4323
4324            columns: t.List[exp.Expression] = []
4325            all_fields = []
4326            for pivot_field in pivot.fields:
4327                pivot_field_expressions = pivot_field.expressions
4328
4329                # The `PivotAny` expression corresponds to `ANY ORDER BY <column>`; we can't infer in this case.
4330                if isinstance(seq_get(pivot_field_expressions, 0), exp.PivotAny):
4331                    continue
4332
4333                all_fields.append(
4334                    [
4335                        fld.sql() if self.IDENTIFY_PIVOT_STRINGS else fld.alias_or_name
4336                        for fld in pivot_field_expressions
4337                    ]
4338                )
4339
4340            if all_fields:
4341                if names:
4342                    all_fields.append(names)
4343
4344                # Generate all possible combinations of the pivot columns
4345                # e.g PIVOT(sum(...) as total FOR year IN (2000, 2010) FOR country IN ('NL', 'US'))
4346                # generates the product between [[2000, 2010], ['NL', 'US'], ['total']]
4347                for fld_parts_tuple in itertools.product(*all_fields):
4348                    fld_parts = list(fld_parts_tuple)
4349
4350                    if names and self.PREFIXED_PIVOT_COLUMNS:
4351                        # Move the "name" to the front of the list
4352                        fld_parts.insert(0, fld_parts.pop(-1))
4353
4354                    columns.append(exp.to_identifier("_".join(fld_parts)))
4355
4356            pivot.set("columns", columns)
4357
4358        return pivot
4359
4360    def _pivot_column_names(self, aggregations: t.List[exp.Expression]) -> t.List[str]:
4361        return [agg.alias for agg in aggregations if agg.alias]
4362
4363    def _parse_prewhere(self, skip_where_token: bool = False) -> t.Optional[exp.PreWhere]:
4364        if not skip_where_token and not self._match(TokenType.PREWHERE):
4365            return None
4366
4367        return self.expression(
4368            exp.PreWhere, comments=self._prev_comments, this=self._parse_assignment()
4369        )
4370
4371    def _parse_where(self, skip_where_token: bool = False) -> t.Optional[exp.Where]:
4372        if not skip_where_token and not self._match(TokenType.WHERE):
4373            return None
4374
4375        return self.expression(
4376            exp.Where, comments=self._prev_comments, this=self._parse_assignment()
4377        )
4378
4379    def _parse_group(self, skip_group_by_token: bool = False) -> t.Optional[exp.Group]:
4380        if not skip_group_by_token and not self._match(TokenType.GROUP_BY):
4381            return None
4382
4383        elements: t.Dict[str, t.Any] = defaultdict(list)
4384
4385        if self._match(TokenType.ALL):
4386            elements["all"] = True
4387        elif self._match(TokenType.DISTINCT):
4388            elements["all"] = False
4389
4390        while True:
4391            index = self._index
4392
4393            elements["expressions"].extend(
4394                self._parse_csv(
4395                    lambda: None
4396                    if self._match_set((TokenType.CUBE, TokenType.ROLLUP), advance=False)
4397                    else self._parse_assignment()
4398                )
4399            )
4400
4401            before_with_index = self._index
4402            with_prefix = self._match(TokenType.WITH)
4403
4404            if self._match(TokenType.ROLLUP):
4405                elements["rollup"].append(
4406                    self._parse_cube_or_rollup(exp.Rollup, with_prefix=with_prefix)
4407                )
4408            elif self._match(TokenType.CUBE):
4409                elements["cube"].append(
4410                    self._parse_cube_or_rollup(exp.Cube, with_prefix=with_prefix)
4411                )
4412            elif self._match(TokenType.GROUPING_SETS):
4413                elements["grouping_sets"].append(
4414                    self.expression(
4415                        exp.GroupingSets,
4416                        expressions=self._parse_wrapped_csv(self._parse_grouping_set),
4417                    )
4418                )
4419            elif self._match_text_seq("TOTALS"):
4420                elements["totals"] = True  # type: ignore
4421
4422            if before_with_index <= self._index <= before_with_index + 1:
4423                self._retreat(before_with_index)
4424                break
4425
4426            if index == self._index:
4427                break
4428
4429        return self.expression(exp.Group, **elements)  # type: ignore
4430
4431    def _parse_cube_or_rollup(self, kind: t.Type[E], with_prefix: bool = False) -> E:
4432        return self.expression(
4433            kind, expressions=[] if with_prefix else self._parse_wrapped_csv(self._parse_column)
4434        )
4435
4436    def _parse_grouping_set(self) -> t.Optional[exp.Expression]:
4437        if self._match(TokenType.L_PAREN):
4438            grouping_set = self._parse_csv(self._parse_column)
4439            self._match_r_paren()
4440            return self.expression(exp.Tuple, expressions=grouping_set)
4441
4442        return self._parse_column()
4443
4444    def _parse_having(self, skip_having_token: bool = False) -> t.Optional[exp.Having]:
4445        if not skip_having_token and not self._match(TokenType.HAVING):
4446            return None
4447        return self.expression(exp.Having, this=self._parse_assignment())
4448
4449    def _parse_qualify(self) -> t.Optional[exp.Qualify]:
4450        if not self._match(TokenType.QUALIFY):
4451            return None
4452        return self.expression(exp.Qualify, this=self._parse_assignment())
4453
4454    def _parse_connect(self, skip_start_token: bool = False) -> t.Optional[exp.Connect]:
4455        if skip_start_token:
4456            start = None
4457        elif self._match(TokenType.START_WITH):
4458            start = self._parse_assignment()
4459        else:
4460            return None
4461
4462        self._match(TokenType.CONNECT_BY)
4463        nocycle = self._match_text_seq("NOCYCLE")
4464        self.NO_PAREN_FUNCTION_PARSERS["PRIOR"] = lambda self: self.expression(
4465            exp.Prior, this=self._parse_bitwise()
4466        )
4467        connect = self._parse_assignment()
4468        self.NO_PAREN_FUNCTION_PARSERS.pop("PRIOR")
4469
4470        if not start and self._match(TokenType.START_WITH):
4471            start = self._parse_assignment()
4472
4473        return self.expression(exp.Connect, start=start, connect=connect, nocycle=nocycle)
4474
4475    def _parse_name_as_expression(self) -> t.Optional[exp.Expression]:
4476        this = self._parse_id_var(any_token=True)
4477        if self._match(TokenType.ALIAS):
4478            this = self.expression(exp.Alias, alias=this, this=self._parse_assignment())
4479        return this
4480
4481    def _parse_interpolate(self) -> t.Optional[t.List[exp.Expression]]:
4482        if self._match_text_seq("INTERPOLATE"):
4483            return self._parse_wrapped_csv(self._parse_name_as_expression)
4484        return None
4485
4486    def _parse_order(
4487        self, this: t.Optional[exp.Expression] = None, skip_order_token: bool = False
4488    ) -> t.Optional[exp.Expression]:
4489        siblings = None
4490        if not skip_order_token and not self._match(TokenType.ORDER_BY):
4491            if not self._match(TokenType.ORDER_SIBLINGS_BY):
4492                return this
4493
4494            siblings = True
4495
4496        return self.expression(
4497            exp.Order,
4498            this=this,
4499            expressions=self._parse_csv(self._parse_ordered),
4500            siblings=siblings,
4501        )
4502
4503    def _parse_sort(self, exp_class: t.Type[E], token: TokenType) -> t.Optional[E]:
4504        if not self._match(token):
4505            return None
4506        return self.expression(exp_class, expressions=self._parse_csv(self._parse_ordered))
4507
4508    def _parse_ordered(
4509        self, parse_method: t.Optional[t.Callable] = None
4510    ) -> t.Optional[exp.Ordered]:
4511        this = parse_method() if parse_method else self._parse_assignment()
4512        if not this:
4513            return None
4514
4515        if this.name.upper() == "ALL" and self.dialect.SUPPORTS_ORDER_BY_ALL:
4516            this = exp.var("ALL")
4517
4518        asc = self._match(TokenType.ASC)
4519        desc = self._match(TokenType.DESC) or (asc and False)
4520
4521        is_nulls_first = self._match_text_seq("NULLS", "FIRST")
4522        is_nulls_last = self._match_text_seq("NULLS", "LAST")
4523
4524        nulls_first = is_nulls_first or False
4525        explicitly_null_ordered = is_nulls_first or is_nulls_last
4526
4527        if (
4528            not explicitly_null_ordered
4529            and (
4530                (not desc and self.dialect.NULL_ORDERING == "nulls_are_small")
4531                or (desc and self.dialect.NULL_ORDERING != "nulls_are_small")
4532            )
4533            and self.dialect.NULL_ORDERING != "nulls_are_last"
4534        ):
4535            nulls_first = True
4536
4537        if self._match_text_seq("WITH", "FILL"):
4538            with_fill = self.expression(
4539                exp.WithFill,
4540                **{  # type: ignore
4541                    "from": self._match(TokenType.FROM) and self._parse_bitwise(),
4542                    "to": self._match_text_seq("TO") and self._parse_bitwise(),
4543                    "step": self._match_text_seq("STEP") and self._parse_bitwise(),
4544                    "interpolate": self._parse_interpolate(),
4545                },
4546            )
4547        else:
4548            with_fill = None
4549
4550        return self.expression(
4551            exp.Ordered, this=this, desc=desc, nulls_first=nulls_first, with_fill=with_fill
4552        )
4553
4554    def _parse_limit_options(self) -> exp.LimitOptions:
4555        percent = self._match(TokenType.PERCENT)
4556        rows = self._match_set((TokenType.ROW, TokenType.ROWS))
4557        self._match_text_seq("ONLY")
4558        with_ties = self._match_text_seq("WITH", "TIES")
4559        return self.expression(exp.LimitOptions, percent=percent, rows=rows, with_ties=with_ties)
4560
4561    def _parse_limit(
4562        self,
4563        this: t.Optional[exp.Expression] = None,
4564        top: bool = False,
4565        skip_limit_token: bool = False,
4566    ) -> t.Optional[exp.Expression]:
4567        if skip_limit_token or self._match(TokenType.TOP if top else TokenType.LIMIT):
4568            comments = self._prev_comments
4569            if top:
4570                limit_paren = self._match(TokenType.L_PAREN)
4571                expression = self._parse_term() if limit_paren else self._parse_number()
4572
4573                if limit_paren:
4574                    self._match_r_paren()
4575
4576                limit_options = self._parse_limit_options()
4577            else:
4578                limit_options = None
4579                expression = self._parse_term()
4580
4581            if self._match(TokenType.COMMA):
4582                offset = expression
4583                expression = self._parse_term()
4584            else:
4585                offset = None
4586
4587            limit_exp = self.expression(
4588                exp.Limit,
4589                this=this,
4590                expression=expression,
4591                offset=offset,
4592                comments=comments,
4593                limit_options=limit_options,
4594                expressions=self._parse_limit_by(),
4595            )
4596
4597            return limit_exp
4598
4599        if self._match(TokenType.FETCH):
4600            direction = self._match_set((TokenType.FIRST, TokenType.NEXT))
4601            direction = self._prev.text.upper() if direction else "FIRST"
4602
4603            count = self._parse_field(tokens=self.FETCH_TOKENS)
4604
4605            return self.expression(
4606                exp.Fetch,
4607                direction=direction,
4608                count=count,
4609                limit_options=self._parse_limit_options(),
4610            )
4611
4612        return this
4613
4614    def _parse_offset(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
4615        if not self._match(TokenType.OFFSET):
4616            return this
4617
4618        count = self._parse_term()
4619        self._match_set((TokenType.ROW, TokenType.ROWS))
4620
4621        return self.expression(
4622            exp.Offset, this=this, expression=count, expressions=self._parse_limit_by()
4623        )
4624
4625    def _can_parse_limit_or_offset(self) -> bool:
4626        if not self._match_set(self.AMBIGUOUS_ALIAS_TOKENS, advance=False):
4627            return False
4628
4629        index = self._index
4630        result = bool(
4631            self._try_parse(self._parse_limit, retreat=True)
4632            or self._try_parse(self._parse_offset, retreat=True)
4633        )
4634        self._retreat(index)
4635        return result
4636
4637    def _parse_limit_by(self) -> t.Optional[t.List[exp.Expression]]:
4638        return self._match_text_seq("BY") and self._parse_csv(self._parse_bitwise)
4639
4640    def _parse_locks(self) -> t.List[exp.Lock]:
4641        locks = []
4642        while True:
4643            if self._match_text_seq("FOR", "UPDATE"):
4644                update = True
4645            elif self._match_text_seq("FOR", "SHARE") or self._match_text_seq(
4646                "LOCK", "IN", "SHARE", "MODE"
4647            ):
4648                update = False
4649            else:
4650                break
4651
4652            expressions = None
4653            if self._match_text_seq("OF"):
4654                expressions = self._parse_csv(lambda: self._parse_table(schema=True))
4655
4656            wait: t.Optional[bool | exp.Expression] = None
4657            if self._match_text_seq("NOWAIT"):
4658                wait = True
4659            elif self._match_text_seq("WAIT"):
4660                wait = self._parse_primary()
4661            elif self._match_text_seq("SKIP", "LOCKED"):
4662                wait = False
4663
4664            locks.append(
4665                self.expression(exp.Lock, update=update, expressions=expressions, wait=wait)
4666            )
4667
4668        return locks
4669
4670    def parse_set_operation(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
4671        start = self._index
4672        _, side_token, kind_token = self._parse_join_parts()
4673
4674        side = side_token.text if side_token else None
4675        kind = kind_token.text if kind_token else None
4676
4677        if not self._match_set(self.SET_OPERATIONS):
4678            self._retreat(start)
4679            return None
4680
4681        token_type = self._prev.token_type
4682
4683        if token_type == TokenType.UNION:
4684            operation: t.Type[exp.SetOperation] = exp.Union
4685        elif token_type == TokenType.EXCEPT:
4686            operation = exp.Except
4687        else:
4688            operation = exp.Intersect
4689
4690        comments = self._prev.comments
4691
4692        if self._match(TokenType.DISTINCT):
4693            distinct: t.Optional[bool] = True
4694        elif self._match(TokenType.ALL):
4695            distinct = False
4696        else:
4697            distinct = self.dialect.SET_OP_DISTINCT_BY_DEFAULT[operation]
4698            if distinct is None:
4699                self.raise_error(f"Expected DISTINCT or ALL for {operation.__name__}")
4700
4701        by_name = self._match_text_seq("BY", "NAME") or self._match_text_seq(
4702            "STRICT", "CORRESPONDING"
4703        )
4704        if self._match_text_seq("CORRESPONDING"):
4705            by_name = True
4706            if not side and not kind:
4707                kind = "INNER"
4708
4709        on_column_list = None
4710        if by_name and self._match_texts(("ON", "BY")):
4711            on_column_list = self._parse_wrapped_csv(self._parse_column)
4712
4713        expression = self._parse_select(nested=True, parse_set_operation=False)
4714
4715        return self.expression(
4716            operation,
4717            comments=comments,
4718            this=this,
4719            distinct=distinct,
4720            by_name=by_name,
4721            expression=expression,
4722            side=side,
4723            kind=kind,
4724            on=on_column_list,
4725        )
4726
4727    def _parse_set_operations(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
4728        while True:
4729            setop = self.parse_set_operation(this)
4730            if not setop:
4731                break
4732            this = setop
4733
4734        if isinstance(this, exp.SetOperation) and self.MODIFIERS_ATTACHED_TO_SET_OP:
4735            expression = this.expression
4736
4737            if expression:
4738                for arg in self.SET_OP_MODIFIERS:
4739                    expr = expression.args.get(arg)
4740                    if expr:
4741                        this.set(arg, expr.pop())
4742
4743        return this
4744
4745    def _parse_expression(self) -> t.Optional[exp.Expression]:
4746        return self._parse_alias(self._parse_assignment())
4747
4748    def _parse_assignment(self) -> t.Optional[exp.Expression]:
4749        this = self._parse_disjunction()
4750        if not this and self._next and self._next.token_type in self.ASSIGNMENT:
4751            # This allows us to parse <non-identifier token> := <expr>
4752            this = exp.column(
4753                t.cast(str, self._advance_any(ignore_reserved=True) and self._prev.text)
4754            )
4755
4756        while self._match_set(self.ASSIGNMENT):
4757            if isinstance(this, exp.Column) and len(this.parts) == 1:
4758                this = this.this
4759
4760            this = self.expression(
4761                self.ASSIGNMENT[self._prev.token_type],
4762                this=this,
4763                comments=self._prev_comments,
4764                expression=self._parse_assignment(),
4765            )
4766
4767        return this
4768
4769    def _parse_disjunction(self) -> t.Optional[exp.Expression]:
4770        return self._parse_tokens(self._parse_conjunction, self.DISJUNCTION)
4771
4772    def _parse_conjunction(self) -> t.Optional[exp.Expression]:
4773        return self._parse_tokens(self._parse_equality, self.CONJUNCTION)
4774
4775    def _parse_equality(self) -> t.Optional[exp.Expression]:
4776        return self._parse_tokens(self._parse_comparison, self.EQUALITY)
4777
4778    def _parse_comparison(self) -> t.Optional[exp.Expression]:
4779        return self._parse_tokens(self._parse_range, self.COMPARISON)
4780
4781    def _parse_range(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
4782        this = this or self._parse_bitwise()
4783        negate = self._match(TokenType.NOT)
4784
4785        if self._match_set(self.RANGE_PARSERS):
4786            expression = self.RANGE_PARSERS[self._prev.token_type](self, this)
4787            if not expression:
4788                return this
4789
4790            this = expression
4791        elif self._match(TokenType.ISNULL):
4792            this = self.expression(exp.Is, this=this, expression=exp.Null())
4793
4794        # Postgres supports ISNULL and NOTNULL for conditions.
4795        # https://blog.andreiavram.ro/postgresql-null-composite-type/
4796        if self._match(TokenType.NOTNULL):
4797            this = self.expression(exp.Is, this=this, expression=exp.Null())
4798            this = self.expression(exp.Not, this=this)
4799
4800        if negate:
4801            this = self._negate_range(this)
4802
4803        if self._match(TokenType.IS):
4804            this = self._parse_is(this)
4805
4806        return this
4807
4808    def _negate_range(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
4809        if not this:
4810            return this
4811
4812        return self.expression(exp.Not, this=this)
4813
4814    def _parse_is(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
4815        index = self._index - 1
4816        negate = self._match(TokenType.NOT)
4817
4818        if self._match_text_seq("DISTINCT", "FROM"):
4819            klass = exp.NullSafeEQ if negate else exp.NullSafeNEQ
4820            return self.expression(klass, this=this, expression=self._parse_bitwise())
4821
4822        if self._match(TokenType.JSON):
4823            kind = self._match_texts(self.IS_JSON_PREDICATE_KIND) and self._prev.text.upper()
4824
4825            if self._match_text_seq("WITH"):
4826                _with = True
4827            elif self._match_text_seq("WITHOUT"):
4828                _with = False
4829            else:
4830                _with = None
4831
4832            unique = self._match(TokenType.UNIQUE)
4833            self._match_text_seq("KEYS")
4834            expression: t.Optional[exp.Expression] = self.expression(
4835                exp.JSON, **{"this": kind, "with": _with, "unique": unique}
4836            )
4837        else:
4838            expression = self._parse_primary() or self._parse_null()
4839            if not expression:
4840                self._retreat(index)
4841                return None
4842
4843        this = self.expression(exp.Is, this=this, expression=expression)
4844        return self.expression(exp.Not, this=this) if negate else this
4845
4846    def _parse_in(self, this: t.Optional[exp.Expression], alias: bool = False) -> exp.In:
4847        unnest = self._parse_unnest(with_alias=False)
4848        if unnest:
4849            this = self.expression(exp.In, this=this, unnest=unnest)
4850        elif self._match_set((TokenType.L_PAREN, TokenType.L_BRACKET)):
4851            matched_l_paren = self._prev.token_type == TokenType.L_PAREN
4852            expressions = self._parse_csv(lambda: self._parse_select_or_expression(alias=alias))
4853
4854            if len(expressions) == 1 and isinstance(expressions[0], exp.Query):
4855                this = self.expression(exp.In, this=this, query=expressions[0].subquery(copy=False))
4856            else:
4857                this = self.expression(exp.In, this=this, expressions=expressions)
4858
4859            if matched_l_paren:
4860                self._match_r_paren(this)
4861            elif not self._match(TokenType.R_BRACKET, expression=this):
4862                self.raise_error("Expecting ]")
4863        else:
4864            this = self.expression(exp.In, this=this, field=self._parse_column())
4865
4866        return this
4867
4868    def _parse_between(self, this: t.Optional[exp.Expression]) -> exp.Between:
4869        low = self._parse_bitwise()
4870        self._match(TokenType.AND)
4871        high = self._parse_bitwise()
4872        return self.expression(exp.Between, this=this, low=low, high=high)
4873
4874    def _parse_escape(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
4875        if not self._match(TokenType.ESCAPE):
4876            return this
4877        return self.expression(exp.Escape, this=this, expression=self._parse_string())
4878
4879    def _parse_interval(self, match_interval: bool = True) -> t.Optional[exp.Add | exp.Interval]:
4880        index = self._index
4881
4882        if not self._match(TokenType.INTERVAL) and match_interval:
4883            return None
4884
4885        if self._match(TokenType.STRING, advance=False):
4886            this = self._parse_primary()
4887        else:
4888            this = self._parse_term()
4889
4890        if not this or (
4891            isinstance(this, exp.Column)
4892            and not this.table
4893            and not this.this.quoted
4894            and this.name.upper() == "IS"
4895        ):
4896            self._retreat(index)
4897            return None
4898
4899        unit = self._parse_function() or (
4900            not self._match(TokenType.ALIAS, advance=False)
4901            and self._parse_var(any_token=True, upper=True)
4902        )
4903
4904        # Most dialects support, e.g., the form INTERVAL '5' day, thus we try to parse
4905        # each INTERVAL expression into this canonical form so it's easy to transpile
4906        if this and this.is_number:
4907            this = exp.Literal.string(this.to_py())
4908        elif this and this.is_string:
4909            parts = exp.INTERVAL_STRING_RE.findall(this.name)
4910            if parts and unit:
4911                # Unconsume the eagerly-parsed unit, since the real unit was part of the string
4912                unit = None
4913                self._retreat(self._index - 1)
4914
4915            if len(parts) == 1:
4916                this = exp.Literal.string(parts[0][0])
4917                unit = self.expression(exp.Var, this=parts[0][1].upper())
4918        if self.INTERVAL_SPANS and self._match_text_seq("TO"):
4919            unit = self.expression(
4920                exp.IntervalSpan, this=unit, expression=self._parse_var(any_token=True, upper=True)
4921            )
4922
4923        interval = self.expression(exp.Interval, this=this, unit=unit)
4924
4925        index = self._index
4926        self._match(TokenType.PLUS)
4927
4928        # Convert INTERVAL 'val_1' unit_1 [+] ... [+] 'val_n' unit_n into a sum of intervals
4929        if self._match_set((TokenType.STRING, TokenType.NUMBER), advance=False):
4930            return self.expression(
4931                exp.Add, this=interval, expression=self._parse_interval(match_interval=False)
4932            )
4933
4934        self._retreat(index)
4935        return interval
4936
4937    def _parse_bitwise(self) -> t.Optional[exp.Expression]:
4938        this = self._parse_term()
4939
4940        while True:
4941            if self._match_set(self.BITWISE):
4942                this = self.expression(
4943                    self.BITWISE[self._prev.token_type],
4944                    this=this,
4945                    expression=self._parse_term(),
4946                )
4947            elif self.dialect.DPIPE_IS_STRING_CONCAT and self._match(TokenType.DPIPE):
4948                this = self.expression(
4949                    exp.DPipe,
4950                    this=this,
4951                    expression=self._parse_term(),
4952                    safe=not self.dialect.STRICT_STRING_CONCAT,
4953                )
4954            elif self._match(TokenType.DQMARK):
4955                this = self.expression(
4956                    exp.Coalesce, this=this, expressions=ensure_list(self._parse_term())
4957                )
4958            elif self._match_pair(TokenType.LT, TokenType.LT):
4959                this = self.expression(
4960                    exp.BitwiseLeftShift, this=this, expression=self._parse_term()
4961                )
4962            elif self._match_pair(TokenType.GT, TokenType.GT):
4963                this = self.expression(
4964                    exp.BitwiseRightShift, this=this, expression=self._parse_term()
4965                )
4966            else:
4967                break
4968
4969        return this
4970
4971    def _parse_term(self) -> t.Optional[exp.Expression]:
4972        this = self._parse_factor()
4973
4974        while self._match_set(self.TERM):
4975            klass = self.TERM[self._prev.token_type]
4976            comments = self._prev_comments
4977            expression = self._parse_factor()
4978
4979            this = self.expression(klass, this=this, comments=comments, expression=expression)
4980
4981            if isinstance(this, exp.Collate):
4982                expr = this.expression
4983
4984                # Preserve collations such as pg_catalog."default" (Postgres) as columns, otherwise
4985                # fallback to Identifier / Var
4986                if isinstance(expr, exp.Column) and len(expr.parts) == 1:
4987                    ident = expr.this
4988                    if isinstance(ident, exp.Identifier):
4989                        this.set("expression", ident if ident.quoted else exp.var(ident.name))
4990
4991        return this
4992
4993    def _parse_factor(self) -> t.Optional[exp.Expression]:
4994        parse_method = self._parse_exponent if self.EXPONENT else self._parse_unary
4995        this = parse_method()
4996
4997        while self._match_set(self.FACTOR):
4998            klass = self.FACTOR[self._prev.token_type]
4999            comments = self._prev_comments
5000            expression = parse_method()
5001
5002            if not expression and klass is exp.IntDiv and self._prev.text.isalpha():
5003                self._retreat(self._index - 1)
5004                return this
5005
5006            this = self.expression(klass, this=this, comments=comments, expression=expression)
5007
5008            if isinstance(this, exp.Div):
5009                this.args["typed"] = self.dialect.TYPED_DIVISION
5010                this.args["safe"] = self.dialect.SAFE_DIVISION
5011
5012        return this
5013
5014    def _parse_exponent(self) -> t.Optional[exp.Expression]:
5015        return self._parse_tokens(self._parse_unary, self.EXPONENT)
5016
5017    def _parse_unary(self) -> t.Optional[exp.Expression]:
5018        if self._match_set(self.UNARY_PARSERS):
5019            return self.UNARY_PARSERS[self._prev.token_type](self)
5020        return self._parse_at_time_zone(self._parse_type())
5021
5022    def _parse_type(
5023        self, parse_interval: bool = True, fallback_to_identifier: bool = False
5024    ) -> t.Optional[exp.Expression]:
5025        interval = parse_interval and self._parse_interval()
5026        if interval:
5027            return interval
5028
5029        index = self._index
5030        data_type = self._parse_types(check_func=True, allow_identifiers=False)
5031
5032        # parse_types() returns a Cast if we parsed BQ's inline constructor <type>(<values>) e.g.
5033        # STRUCT<a INT, b STRING>(1, 'foo'), which is canonicalized to CAST(<values> AS <type>)
5034        if isinstance(data_type, exp.Cast):
5035            # This constructor can contain ops directly after it, for instance struct unnesting:
5036            # STRUCT<a INT, b STRING>(1, 'foo').* --> CAST(STRUCT(1, 'foo') AS STRUCT<a iNT, b STRING).*
5037            return self._parse_column_ops(data_type)
5038
5039        if data_type:
5040            index2 = self._index
5041            this = self._parse_primary()
5042
5043            if isinstance(this, exp.Literal):
5044                this = self._parse_column_ops(this)
5045
5046                parser = self.TYPE_LITERAL_PARSERS.get(data_type.this)
5047                if parser:
5048                    return parser(self, this, data_type)
5049
5050                return self.expression(exp.Cast, this=this, to=data_type)
5051
5052            # The expressions arg gets set by the parser when we have something like DECIMAL(38, 0)
5053            # in the input SQL. In that case, we'll produce these tokens: DECIMAL ( 38 , 0 )
5054            #
5055            # If the index difference here is greater than 1, that means the parser itself must have
5056            # consumed additional tokens such as the DECIMAL scale and precision in the above example.
5057            #
5058            # If it's not greater than 1, then it must be 1, because we've consumed at least the type
5059            # keyword, meaning that the expressions arg of the DataType must have gotten set by a
5060            # callable in the TYPE_CONVERTERS mapping. For example, Snowflake converts DECIMAL to
5061            # DECIMAL(38, 0)) in order to facilitate the data type's transpilation.
5062            #
5063            # In these cases, we don't really want to return the converted type, but instead retreat
5064            # and try to parse a Column or Identifier in the section below.
5065            if data_type.expressions and index2 - index > 1:
5066                self._retreat(index2)
5067                return self._parse_column_ops(data_type)
5068
5069            self._retreat(index)
5070
5071        if fallback_to_identifier:
5072            return self._parse_id_var()
5073
5074        this = self._parse_column()
5075        return this and self._parse_column_ops(this)
5076
5077    def _parse_type_size(self) -> t.Optional[exp.DataTypeParam]:
5078        this = self._parse_type()
5079        if not this:
5080            return None
5081
5082        if isinstance(this, exp.Column) and not this.table:
5083            this = exp.var(this.name.upper())
5084
5085        return self.expression(
5086            exp.DataTypeParam, this=this, expression=self._parse_var(any_token=True)
5087        )
5088
5089    def _parse_types(
5090        self, check_func: bool = False, schema: bool = False, allow_identifiers: bool = True
5091    ) -> t.Optional[exp.Expression]:
5092        index = self._index
5093
5094        this: t.Optional[exp.Expression] = None
5095        prefix = self._match_text_seq("SYSUDTLIB", ".")
5096
5097        if not self._match_set(self.TYPE_TOKENS):
5098            identifier = allow_identifiers and self._parse_id_var(
5099                any_token=False, tokens=(TokenType.VAR,)
5100            )
5101            if isinstance(identifier, exp.Identifier):
5102                tokens = self.dialect.tokenize(identifier.sql(dialect=self.dialect))
5103
5104                if len(tokens) != 1:
5105                    self.raise_error("Unexpected identifier", self._prev)
5106
5107                if tokens[0].token_type in self.TYPE_TOKENS:
5108                    self._prev = tokens[0]
5109                elif self.dialect.SUPPORTS_USER_DEFINED_TYPES:
5110                    type_name = identifier.name
5111
5112                    while self._match(TokenType.DOT):
5113                        type_name = f"{type_name}.{self._advance_any() and self._prev.text}"
5114
5115                    this = exp.DataType.build(type_name, udt=True)
5116                else:
5117                    self._retreat(self._index - 1)
5118                    return None
5119            else:
5120                return None
5121
5122        type_token = self._prev.token_type
5123
5124        if type_token == TokenType.PSEUDO_TYPE:
5125            return self.expression(exp.PseudoType, this=self._prev.text.upper())
5126
5127        if type_token == TokenType.OBJECT_IDENTIFIER:
5128            return self.expression(exp.ObjectIdentifier, this=self._prev.text.upper())
5129
5130        # https://materialize.com/docs/sql/types/map/
5131        if type_token == TokenType.MAP and self._match(TokenType.L_BRACKET):
5132            key_type = self._parse_types(
5133                check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
5134            )
5135            if not self._match(TokenType.FARROW):
5136                self._retreat(index)
5137                return None
5138
5139            value_type = self._parse_types(
5140                check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
5141            )
5142            if not self._match(TokenType.R_BRACKET):
5143                self._retreat(index)
5144                return None
5145
5146            return exp.DataType(
5147                this=exp.DataType.Type.MAP,
5148                expressions=[key_type, value_type],
5149                nested=True,
5150                prefix=prefix,
5151            )
5152
5153        nested = type_token in self.NESTED_TYPE_TOKENS
5154        is_struct = type_token in self.STRUCT_TYPE_TOKENS
5155        is_aggregate = type_token in self.AGGREGATE_TYPE_TOKENS
5156        expressions = None
5157        maybe_func = False
5158
5159        if self._match(TokenType.L_PAREN):
5160            if is_struct:
5161                expressions = self._parse_csv(lambda: self._parse_struct_types(type_required=True))
5162            elif nested:
5163                expressions = self._parse_csv(
5164                    lambda: self._parse_types(
5165                        check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
5166                    )
5167                )
5168                if type_token == TokenType.NULLABLE and len(expressions) == 1:
5169                    this = expressions[0]
5170                    this.set("nullable", True)
5171                    self._match_r_paren()
5172                    return this
5173            elif type_token in self.ENUM_TYPE_TOKENS:
5174                expressions = self._parse_csv(self._parse_equality)
5175            elif is_aggregate:
5176                func_or_ident = self._parse_function(anonymous=True) or self._parse_id_var(
5177                    any_token=False, tokens=(TokenType.VAR, TokenType.ANY)
5178                )
5179                if not func_or_ident:
5180                    return None
5181                expressions = [func_or_ident]
5182                if self._match(TokenType.COMMA):
5183                    expressions.extend(
5184                        self._parse_csv(
5185                            lambda: self._parse_types(
5186                                check_func=check_func,
5187                                schema=schema,
5188                                allow_identifiers=allow_identifiers,
5189                            )
5190                        )
5191                    )
5192            else:
5193                expressions = self._parse_csv(self._parse_type_size)
5194
5195                # https://docs.snowflake.com/en/sql-reference/data-types-vector
5196                if type_token == TokenType.VECTOR and len(expressions) == 2:
5197                    expressions[0] = exp.DataType.build(expressions[0].name, dialect=self.dialect)
5198
5199            if not expressions or not self._match(TokenType.R_PAREN):
5200                self._retreat(index)
5201                return None
5202
5203            maybe_func = True
5204
5205        values: t.Optional[t.List[exp.Expression]] = None
5206
5207        if nested and self._match(TokenType.LT):
5208            if is_struct:
5209                expressions = self._parse_csv(lambda: self._parse_struct_types(type_required=True))
5210            else:
5211                expressions = self._parse_csv(
5212                    lambda: self._parse_types(
5213                        check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
5214                    )
5215                )
5216
5217            if not self._match(TokenType.GT):
5218                self.raise_error("Expecting >")
5219
5220            if self._match_set((TokenType.L_BRACKET, TokenType.L_PAREN)):
5221                values = self._parse_csv(self._parse_assignment)
5222                if not values and is_struct:
5223                    values = None
5224                    self._retreat(self._index - 1)
5225                else:
5226                    self._match_set((TokenType.R_BRACKET, TokenType.R_PAREN))
5227
5228        if type_token in self.TIMESTAMPS:
5229            if self._match_text_seq("WITH", "TIME", "ZONE"):
5230                maybe_func = False
5231                tz_type = (
5232                    exp.DataType.Type.TIMETZ
5233                    if type_token in self.TIMES
5234                    else exp.DataType.Type.TIMESTAMPTZ
5235                )
5236                this = exp.DataType(this=tz_type, expressions=expressions)
5237            elif self._match_text_seq("WITH", "LOCAL", "TIME", "ZONE"):
5238                maybe_func = False
5239                this = exp.DataType(this=exp.DataType.Type.TIMESTAMPLTZ, expressions=expressions)
5240            elif self._match_text_seq("WITHOUT", "TIME", "ZONE"):
5241                maybe_func = False
5242        elif type_token == TokenType.INTERVAL:
5243            unit = self._parse_var(upper=True)
5244            if unit:
5245                if self._match_text_seq("TO"):
5246                    unit = exp.IntervalSpan(this=unit, expression=self._parse_var(upper=True))
5247
5248                this = self.expression(exp.DataType, this=self.expression(exp.Interval, unit=unit))
5249            else:
5250                this = self.expression(exp.DataType, this=exp.DataType.Type.INTERVAL)
5251        elif type_token == TokenType.VOID:
5252            this = exp.DataType(this=exp.DataType.Type.NULL)
5253
5254        if maybe_func and check_func:
5255            index2 = self._index
5256            peek = self._parse_string()
5257
5258            if not peek:
5259                self._retreat(index)
5260                return None
5261
5262            self._retreat(index2)
5263
5264        if not this:
5265            if self._match_text_seq("UNSIGNED"):
5266                unsigned_type_token = self.SIGNED_TO_UNSIGNED_TYPE_TOKEN.get(type_token)
5267                if not unsigned_type_token:
5268                    self.raise_error(f"Cannot convert {type_token.value} to unsigned.")
5269
5270                type_token = unsigned_type_token or type_token
5271
5272            this = exp.DataType(
5273                this=exp.DataType.Type[type_token.value],
5274                expressions=expressions,
5275                nested=nested,
5276                prefix=prefix,
5277            )
5278
5279            # Empty arrays/structs are allowed
5280            if values is not None:
5281                cls = exp.Struct if is_struct else exp.Array
5282                this = exp.cast(cls(expressions=values), this, copy=False)
5283
5284        elif expressions:
5285            this.set("expressions", expressions)
5286
5287        # https://materialize.com/docs/sql/types/list/#type-name
5288        while self._match(TokenType.LIST):
5289            this = exp.DataType(this=exp.DataType.Type.LIST, expressions=[this], nested=True)
5290
5291        index = self._index
5292
5293        # Postgres supports the INT ARRAY[3] syntax as a synonym for INT[3]
5294        matched_array = self._match(TokenType.ARRAY)
5295
5296        while self._curr:
5297            datatype_token = self._prev.token_type
5298            matched_l_bracket = self._match(TokenType.L_BRACKET)
5299
5300            if (not matched_l_bracket and not matched_array) or (
5301                datatype_token == TokenType.ARRAY and self._match(TokenType.R_BRACKET)
5302            ):
5303                # Postgres allows casting empty arrays such as ARRAY[]::INT[],
5304                # not to be confused with the fixed size array parsing
5305                break
5306
5307            matched_array = False
5308            values = self._parse_csv(self._parse_assignment) or None
5309            if (
5310                values
5311                and not schema
5312                and (
5313                    not self.dialect.SUPPORTS_FIXED_SIZE_ARRAYS or datatype_token == TokenType.ARRAY
5314                )
5315            ):
5316                # Retreating here means that we should not parse the following values as part of the data type, e.g. in DuckDB
5317                # ARRAY[1] should retreat and instead be parsed into exp.Array in contrast to INT[x][y] which denotes a fixed-size array data type
5318                self._retreat(index)
5319                break
5320
5321            this = exp.DataType(
5322                this=exp.DataType.Type.ARRAY, expressions=[this], values=values, nested=True
5323            )
5324            self._match(TokenType.R_BRACKET)
5325
5326        if self.TYPE_CONVERTERS and isinstance(this.this, exp.DataType.Type):
5327            converter = self.TYPE_CONVERTERS.get(this.this)
5328            if converter:
5329                this = converter(t.cast(exp.DataType, this))
5330
5331        return this
5332
5333    def _parse_struct_types(self, type_required: bool = False) -> t.Optional[exp.Expression]:
5334        index = self._index
5335
5336        if (
5337            self._curr
5338            and self._next
5339            and self._curr.token_type in self.TYPE_TOKENS
5340            and self._next.token_type in self.TYPE_TOKENS
5341        ):
5342            # Takes care of special cases like `STRUCT<list ARRAY<...>>` where the identifier is also a
5343            # type token. Without this, the list will be parsed as a type and we'll eventually crash
5344            this = self._parse_id_var()
5345        else:
5346            this = (
5347                self._parse_type(parse_interval=False, fallback_to_identifier=True)
5348                or self._parse_id_var()
5349            )
5350
5351        self._match(TokenType.COLON)
5352
5353        if (
5354            type_required
5355            and not isinstance(this, exp.DataType)
5356            and not self._match_set(self.TYPE_TOKENS, advance=False)
5357        ):
5358            self._retreat(index)
5359            return self._parse_types()
5360
5361        return self._parse_column_def(this)
5362
5363    def _parse_at_time_zone(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
5364        if not self._match_text_seq("AT", "TIME", "ZONE"):
5365            return this
5366        return self.expression(exp.AtTimeZone, this=this, zone=self._parse_unary())
5367
5368    def _parse_column(self) -> t.Optional[exp.Expression]:
5369        this = self._parse_column_reference()
5370        column = self._parse_column_ops(this) if this else self._parse_bracket(this)
5371
5372        if self.dialect.SUPPORTS_COLUMN_JOIN_MARKS and column:
5373            column.set("join_mark", self._match(TokenType.JOIN_MARKER))
5374
5375        return column
5376
5377    def _parse_column_reference(self) -> t.Optional[exp.Expression]:
5378        this = self._parse_field()
5379        if (
5380            not this
5381            and self._match(TokenType.VALUES, advance=False)
5382            and self.VALUES_FOLLOWED_BY_PAREN
5383            and (not self._next or self._next.token_type != TokenType.L_PAREN)
5384        ):
5385            this = self._parse_id_var()
5386
5387        if isinstance(this, exp.Identifier):
5388            # We bubble up comments from the Identifier to the Column
5389            this = self.expression(exp.Column, comments=this.pop_comments(), this=this)
5390
5391        return this
5392
5393    def _parse_colon_as_variant_extract(
5394        self, this: t.Optional[exp.Expression]
5395    ) -> t.Optional[exp.Expression]:
5396        casts = []
5397        json_path = []
5398        escape = None
5399
5400        while self._match(TokenType.COLON):
5401            start_index = self._index
5402
5403            # Snowflake allows reserved keywords as json keys but advance_any() excludes TokenType.SELECT from any_tokens=True
5404            path = self._parse_column_ops(
5405                self._parse_field(any_token=True, tokens=(TokenType.SELECT,))
5406            )
5407
5408            # The cast :: operator has a lower precedence than the extraction operator :, so
5409            # we rearrange the AST appropriately to avoid casting the JSON path
5410            while isinstance(path, exp.Cast):
5411                casts.append(path.to)
5412                path = path.this
5413
5414            if casts:
5415                dcolon_offset = next(
5416                    i
5417                    for i, t in enumerate(self._tokens[start_index:])
5418                    if t.token_type == TokenType.DCOLON
5419                )
5420                end_token = self._tokens[start_index + dcolon_offset - 1]
5421            else:
5422                end_token = self._prev
5423
5424            if path:
5425                # Escape single quotes from Snowflake's colon extraction (e.g. col:"a'b") as
5426                # it'll roundtrip to a string literal in GET_PATH
5427                if isinstance(path, exp.Identifier) and path.quoted:
5428                    escape = True
5429
5430                json_path.append(self._find_sql(self._tokens[start_index], end_token))
5431
5432        # The VARIANT extract in Snowflake/Databricks is parsed as a JSONExtract; Snowflake uses the json_path in GET_PATH() while
5433        # Databricks transforms it back to the colon/dot notation
5434        if json_path:
5435            json_path_expr = self.dialect.to_json_path(exp.Literal.string(".".join(json_path)))
5436
5437            if json_path_expr:
5438                json_path_expr.set("escape", escape)
5439
5440            this = self.expression(
5441                exp.JSONExtract,
5442                this=this,
5443                expression=json_path_expr,
5444                variant_extract=True,
5445            )
5446
5447            while casts:
5448                this = self.expression(exp.Cast, this=this, to=casts.pop())
5449
5450        return this
5451
5452    def _parse_dcolon(self) -> t.Optional[exp.Expression]:
5453        return self._parse_types()
5454
5455    def _parse_column_ops(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
5456        this = self._parse_bracket(this)
5457
5458        while self._match_set(self.COLUMN_OPERATORS):
5459            op_token = self._prev.token_type
5460            op = self.COLUMN_OPERATORS.get(op_token)
5461
5462            if op_token in (TokenType.DCOLON, TokenType.DOTCOLON):
5463                field = self._parse_dcolon()
5464                if not field:
5465                    self.raise_error("Expected type")
5466            elif op and self._curr:
5467                field = self._parse_column_reference() or self._parse_bracket()
5468                if isinstance(field, exp.Column) and self._match(TokenType.DOT, advance=False):
5469                    field = self._parse_column_ops(field)
5470            else:
5471                field = self._parse_field(any_token=True, anonymous_func=True)
5472
5473            if isinstance(field, (exp.Func, exp.Window)) and this:
5474                # BQ & snowflake allow function calls like x.y.count(...), SAFE.SUBSTR(...) etc
5475                # https://cloud.google.com/bigquery/docs/reference/standard-sql/functions-reference#function_call_rules
5476                this = exp.replace_tree(
5477                    this,
5478                    lambda n: (
5479                        self.expression(exp.Dot, this=n.args.get("table"), expression=n.this)
5480                        if n.table
5481                        else n.this
5482                    )
5483                    if isinstance(n, exp.Column)
5484                    else n,
5485                )
5486
5487            if op:
5488                this = op(self, this, field)
5489            elif isinstance(this, exp.Column) and not this.args.get("catalog"):
5490                this = self.expression(
5491                    exp.Column,
5492                    comments=this.comments,
5493                    this=field,
5494                    table=this.this,
5495                    db=this.args.get("table"),
5496                    catalog=this.args.get("db"),
5497                )
5498            elif isinstance(field, exp.Window):
5499                # Move the exp.Dot's to the window's function
5500                window_func = self.expression(exp.Dot, this=this, expression=field.this)
5501                field.set("this", window_func)
5502                this = field
5503            else:
5504                this = self.expression(exp.Dot, this=this, expression=field)
5505
5506            if field and field.comments:
5507                t.cast(exp.Expression, this).add_comments(field.pop_comments())
5508
5509            this = self._parse_bracket(this)
5510
5511        return self._parse_colon_as_variant_extract(this) if self.COLON_IS_VARIANT_EXTRACT else this
5512
5513    def _parse_primary(self) -> t.Optional[exp.Expression]:
5514        if self._match_set(self.PRIMARY_PARSERS):
5515            token_type = self._prev.token_type
5516            primary = self.PRIMARY_PARSERS[token_type](self, self._prev)
5517
5518            if token_type == TokenType.STRING:
5519                expressions = [primary]
5520                while self._match(TokenType.STRING):
5521                    expressions.append(exp.Literal.string(self._prev.text))
5522
5523                if len(expressions) > 1:
5524                    return self.expression(exp.Concat, expressions=expressions)
5525
5526            return primary
5527
5528        if self._match_pair(TokenType.DOT, TokenType.NUMBER):
5529            return exp.Literal.number(f"0.{self._prev.text}")
5530
5531        if self._match(TokenType.L_PAREN):
5532            comments = self._prev_comments
5533            query = self._parse_select()
5534
5535            if query:
5536                expressions = [query]
5537            else:
5538                expressions = self._parse_expressions()
5539
5540            this = self._parse_query_modifiers(seq_get(expressions, 0))
5541
5542            if not this and self._match(TokenType.R_PAREN, advance=False):
5543                this = self.expression(exp.Tuple)
5544            elif isinstance(this, exp.UNWRAPPED_QUERIES):
5545                this = self._parse_subquery(this=this, parse_alias=False)
5546            elif isinstance(this, exp.Subquery):
5547                this = self._parse_subquery(
5548                    this=self._parse_set_operations(this), parse_alias=False
5549                )
5550            elif len(expressions) > 1 or self._prev.token_type == TokenType.COMMA:
5551                this = self.expression(exp.Tuple, expressions=expressions)
5552            else:
5553                this = self.expression(exp.Paren, this=this)
5554
5555            if this:
5556                this.add_comments(comments)
5557
5558            self._match_r_paren(expression=this)
5559            return this
5560
5561        return None
5562
5563    def _parse_field(
5564        self,
5565        any_token: bool = False,
5566        tokens: t.Optional[t.Collection[TokenType]] = None,
5567        anonymous_func: bool = False,
5568    ) -> t.Optional[exp.Expression]:
5569        if anonymous_func:
5570            field = (
5571                self._parse_function(anonymous=anonymous_func, any_token=any_token)
5572                or self._parse_primary()
5573            )
5574        else:
5575            field = self._parse_primary() or self._parse_function(
5576                anonymous=anonymous_func, any_token=any_token
5577            )
5578        return field or self._parse_id_var(any_token=any_token, tokens=tokens)
5579
5580    def _parse_function(
5581        self,
5582        functions: t.Optional[t.Dict[str, t.Callable]] = None,
5583        anonymous: bool = False,
5584        optional_parens: bool = True,
5585        any_token: bool = False,
5586    ) -> t.Optional[exp.Expression]:
5587        # This allows us to also parse {fn <function>} syntax (Snowflake, MySQL support this)
5588        # See: https://community.snowflake.com/s/article/SQL-Escape-Sequences
5589        fn_syntax = False
5590        if (
5591            self._match(TokenType.L_BRACE, advance=False)
5592            and self._next
5593            and self._next.text.upper() == "FN"
5594        ):
5595            self._advance(2)
5596            fn_syntax = True
5597
5598        func = self._parse_function_call(
5599            functions=functions,
5600            anonymous=anonymous,
5601            optional_parens=optional_parens,
5602            any_token=any_token,
5603        )
5604
5605        if fn_syntax:
5606            self._match(TokenType.R_BRACE)
5607
5608        return func
5609
5610    def _parse_function_call(
5611        self,
5612        functions: t.Optional[t.Dict[str, t.Callable]] = None,
5613        anonymous: bool = False,
5614        optional_parens: bool = True,
5615        any_token: bool = False,
5616    ) -> t.Optional[exp.Expression]:
5617        if not self._curr:
5618            return None
5619
5620        comments = self._curr.comments
5621        token = self._curr
5622        token_type = self._curr.token_type
5623        this = self._curr.text
5624        upper = this.upper()
5625
5626        parser = self.NO_PAREN_FUNCTION_PARSERS.get(upper)
5627        if optional_parens and parser and token_type not in self.INVALID_FUNC_NAME_TOKENS:
5628            self._advance()
5629            return self._parse_window(parser(self))
5630
5631        if not self._next or self._next.token_type != TokenType.L_PAREN:
5632            if optional_parens and token_type in self.NO_PAREN_FUNCTIONS:
5633                self._advance()
5634                return self.expression(self.NO_PAREN_FUNCTIONS[token_type])
5635
5636            return None
5637
5638        if any_token:
5639            if token_type in self.RESERVED_TOKENS:
5640                return None
5641        elif token_type not in self.FUNC_TOKENS:
5642            return None
5643
5644        self._advance(2)
5645
5646        parser = self.FUNCTION_PARSERS.get(upper)
5647        if parser and not anonymous:
5648            this = parser(self)
5649        else:
5650            subquery_predicate = self.SUBQUERY_PREDICATES.get(token_type)
5651
5652            if subquery_predicate and self._curr.token_type in (TokenType.SELECT, TokenType.WITH):
5653                this = self.expression(
5654                    subquery_predicate, comments=comments, this=self._parse_select()
5655                )
5656                self._match_r_paren()
5657                return this
5658
5659            if functions is None:
5660                functions = self.FUNCTIONS
5661
5662            function = functions.get(upper)
5663            known_function = function and not anonymous
5664
5665            alias = not known_function or upper in self.FUNCTIONS_WITH_ALIASED_ARGS
5666            args = self._parse_csv(lambda: self._parse_lambda(alias=alias))
5667
5668            post_func_comments = self._curr and self._curr.comments
5669            if known_function and post_func_comments:
5670                # If the user-inputted comment "/* sqlglot.anonymous */" is following the function
5671                # call we'll construct it as exp.Anonymous, even if it's "known"
5672                if any(
5673                    comment.lstrip().startswith(exp.SQLGLOT_ANONYMOUS)
5674                    for comment in post_func_comments
5675                ):
5676                    known_function = False
5677
5678            if alias and known_function:
5679                args = self._kv_to_prop_eq(args)
5680
5681            if known_function:
5682                func_builder = t.cast(t.Callable, function)
5683
5684                if "dialect" in func_builder.__code__.co_varnames:
5685                    func = func_builder(args, dialect=self.dialect)
5686                else:
5687                    func = func_builder(args)
5688
5689                func = self.validate_expression(func, args)
5690                if self.dialect.PRESERVE_ORIGINAL_NAMES:
5691                    func.meta["name"] = this
5692
5693                this = func
5694            else:
5695                if token_type == TokenType.IDENTIFIER:
5696                    this = exp.Identifier(this=this, quoted=True).update_positions(token)
5697                this = self.expression(exp.Anonymous, this=this, expressions=args)
5698
5699        if isinstance(this, exp.Expression):
5700            this.add_comments(comments)
5701
5702        self._match_r_paren(this)
5703        return self._parse_window(this)
5704
5705    def _to_prop_eq(self, expression: exp.Expression, index: int) -> exp.Expression:
5706        return expression
5707
5708    def _kv_to_prop_eq(self, expressions: t.List[exp.Expression]) -> t.List[exp.Expression]:
5709        transformed = []
5710
5711        for index, e in enumerate(expressions):
5712            if isinstance(e, self.KEY_VALUE_DEFINITIONS):
5713                if isinstance(e, exp.Alias):
5714                    e = self.expression(exp.PropertyEQ, this=e.args.get("alias"), expression=e.this)
5715
5716                if not isinstance(e, exp.PropertyEQ):
5717                    e = self.expression(
5718                        exp.PropertyEQ, this=exp.to_identifier(e.this.name), expression=e.expression
5719                    )
5720
5721                if isinstance(e.this, exp.Column):
5722                    e.this.replace(e.this.this)
5723            else:
5724                e = self._to_prop_eq(e, index)
5725
5726            transformed.append(e)
5727
5728        return transformed
5729
5730    def _parse_user_defined_function_expression(self) -> t.Optional[exp.Expression]:
5731        return self._parse_statement()
5732
5733    def _parse_function_parameter(self) -> t.Optional[exp.Expression]:
5734        return self._parse_column_def(this=self._parse_id_var(), computed_column=False)
5735
5736    def _parse_user_defined_function(
5737        self, kind: t.Optional[TokenType] = None
5738    ) -> t.Optional[exp.Expression]:
5739        this = self._parse_table_parts(schema=True)
5740
5741        if not self._match(TokenType.L_PAREN):
5742            return this
5743
5744        expressions = self._parse_csv(self._parse_function_parameter)
5745        self._match_r_paren()
5746        return self.expression(
5747            exp.UserDefinedFunction, this=this, expressions=expressions, wrapped=True
5748        )
5749
5750    def _parse_introducer(self, token: Token) -> exp.Introducer | exp.Identifier:
5751        literal = self._parse_primary()
5752        if literal:
5753            return self.expression(exp.Introducer, this=token.text, expression=literal)
5754
5755        return self._identifier_expression(token)
5756
5757    def _parse_session_parameter(self) -> exp.SessionParameter:
5758        kind = None
5759        this = self._parse_id_var() or self._parse_primary()
5760
5761        if this and self._match(TokenType.DOT):
5762            kind = this.name
5763            this = self._parse_var() or self._parse_primary()
5764
5765        return self.expression(exp.SessionParameter, this=this, kind=kind)
5766
5767    def _parse_lambda_arg(self) -> t.Optional[exp.Expression]:
5768        return self._parse_id_var()
5769
5770    def _parse_lambda(self, alias: bool = False) -> t.Optional[exp.Expression]:
5771        index = self._index
5772
5773        if self._match(TokenType.L_PAREN):
5774            expressions = t.cast(
5775                t.List[t.Optional[exp.Expression]], self._parse_csv(self._parse_lambda_arg)
5776            )
5777
5778            if not self._match(TokenType.R_PAREN):
5779                self._retreat(index)
5780        else:
5781            expressions = [self._parse_lambda_arg()]
5782
5783        if self._match_set(self.LAMBDAS):
5784            return self.LAMBDAS[self._prev.token_type](self, expressions)
5785
5786        self._retreat(index)
5787
5788        this: t.Optional[exp.Expression]
5789
5790        if self._match(TokenType.DISTINCT):
5791            this = self.expression(
5792                exp.Distinct, expressions=self._parse_csv(self._parse_assignment)
5793            )
5794        else:
5795            this = self._parse_select_or_expression(alias=alias)
5796
5797        return self._parse_limit(
5798            self._parse_order(self._parse_having_max(self._parse_respect_or_ignore_nulls(this)))
5799        )
5800
5801    def _parse_schema(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
5802        index = self._index
5803        if not self._match(TokenType.L_PAREN):
5804            return this
5805
5806        # Disambiguate between schema and subquery/CTE, e.g. in INSERT INTO table (<expr>),
5807        # expr can be of both types
5808        if self._match_set(self.SELECT_START_TOKENS):
5809            self._retreat(index)
5810            return this
5811        args = self._parse_csv(lambda: self._parse_constraint() or self._parse_field_def())
5812        self._match_r_paren()
5813        return self.expression(exp.Schema, this=this, expressions=args)
5814
5815    def _parse_field_def(self) -> t.Optional[exp.Expression]:
5816        return self._parse_column_def(self._parse_field(any_token=True))
5817
5818    def _parse_column_def(
5819        self, this: t.Optional[exp.Expression], computed_column: bool = True
5820    ) -> t.Optional[exp.Expression]:
5821        # column defs are not really columns, they're identifiers
5822        if isinstance(this, exp.Column):
5823            this = this.this
5824
5825        if not computed_column:
5826            self._match(TokenType.ALIAS)
5827
5828        kind = self._parse_types(schema=True)
5829
5830        if self._match_text_seq("FOR", "ORDINALITY"):
5831            return self.expression(exp.ColumnDef, this=this, ordinality=True)
5832
5833        constraints: t.List[exp.Expression] = []
5834
5835        if (not kind and self._match(TokenType.ALIAS)) or self._match_texts(
5836            ("ALIAS", "MATERIALIZED")
5837        ):
5838            persisted = self._prev.text.upper() == "MATERIALIZED"
5839            constraint_kind = exp.ComputedColumnConstraint(
5840                this=self._parse_assignment(),
5841                persisted=persisted or self._match_text_seq("PERSISTED"),
5842                not_null=self._match_pair(TokenType.NOT, TokenType.NULL),
5843            )
5844            constraints.append(self.expression(exp.ColumnConstraint, kind=constraint_kind))
5845        elif (
5846            kind
5847            and self._match(TokenType.ALIAS, advance=False)
5848            and (
5849                not self.WRAPPED_TRANSFORM_COLUMN_CONSTRAINT
5850                or (self._next and self._next.token_type == TokenType.L_PAREN)
5851            )
5852        ):
5853            self._advance()
5854            constraints.append(
5855                self.expression(
5856                    exp.ColumnConstraint,
5857                    kind=exp.TransformColumnConstraint(this=self._parse_disjunction()),
5858                )
5859            )
5860
5861        while True:
5862            constraint = self._parse_column_constraint()
5863            if not constraint:
5864                break
5865            constraints.append(constraint)
5866
5867        if not kind and not constraints:
5868            return this
5869
5870        return self.expression(exp.ColumnDef, this=this, kind=kind, constraints=constraints)
5871
5872    def _parse_auto_increment(
5873        self,
5874    ) -> exp.GeneratedAsIdentityColumnConstraint | exp.AutoIncrementColumnConstraint:
5875        start = None
5876        increment = None
5877
5878        if self._match(TokenType.L_PAREN, advance=False):
5879            args = self._parse_wrapped_csv(self._parse_bitwise)
5880            start = seq_get(args, 0)
5881            increment = seq_get(args, 1)
5882        elif self._match_text_seq("START"):
5883            start = self._parse_bitwise()
5884            self._match_text_seq("INCREMENT")
5885            increment = self._parse_bitwise()
5886
5887        if start and increment:
5888            return exp.GeneratedAsIdentityColumnConstraint(
5889                start=start, increment=increment, this=False
5890            )
5891
5892        return exp.AutoIncrementColumnConstraint()
5893
5894    def _parse_auto_property(self) -> t.Optional[exp.AutoRefreshProperty]:
5895        if not self._match_text_seq("REFRESH"):
5896            self._retreat(self._index - 1)
5897            return None
5898        return self.expression(exp.AutoRefreshProperty, this=self._parse_var(upper=True))
5899
5900    def _parse_compress(self) -> exp.CompressColumnConstraint:
5901        if self._match(TokenType.L_PAREN, advance=False):
5902            return self.expression(
5903                exp.CompressColumnConstraint, this=self._parse_wrapped_csv(self._parse_bitwise)
5904            )
5905
5906        return self.expression(exp.CompressColumnConstraint, this=self._parse_bitwise())
5907
5908    def _parse_generated_as_identity(
5909        self,
5910    ) -> (
5911        exp.GeneratedAsIdentityColumnConstraint
5912        | exp.ComputedColumnConstraint
5913        | exp.GeneratedAsRowColumnConstraint
5914    ):
5915        if self._match_text_seq("BY", "DEFAULT"):
5916            on_null = self._match_pair(TokenType.ON, TokenType.NULL)
5917            this = self.expression(
5918                exp.GeneratedAsIdentityColumnConstraint, this=False, on_null=on_null
5919            )
5920        else:
5921            self._match_text_seq("ALWAYS")
5922            this = self.expression(exp.GeneratedAsIdentityColumnConstraint, this=True)
5923
5924        self._match(TokenType.ALIAS)
5925
5926        if self._match_text_seq("ROW"):
5927            start = self._match_text_seq("START")
5928            if not start:
5929                self._match(TokenType.END)
5930            hidden = self._match_text_seq("HIDDEN")
5931            return self.expression(exp.GeneratedAsRowColumnConstraint, start=start, hidden=hidden)
5932
5933        identity = self._match_text_seq("IDENTITY")
5934
5935        if self._match(TokenType.L_PAREN):
5936            if self._match(TokenType.START_WITH):
5937                this.set("start", self._parse_bitwise())
5938            if self._match_text_seq("INCREMENT", "BY"):
5939                this.set("increment", self._parse_bitwise())
5940            if self._match_text_seq("MINVALUE"):
5941                this.set("minvalue", self._parse_bitwise())
5942            if self._match_text_seq("MAXVALUE"):
5943                this.set("maxvalue", self._parse_bitwise())
5944
5945            if self._match_text_seq("CYCLE"):
5946                this.set("cycle", True)
5947            elif self._match_text_seq("NO", "CYCLE"):
5948                this.set("cycle", False)
5949
5950            if not identity:
5951                this.set("expression", self._parse_range())
5952            elif not this.args.get("start") and self._match(TokenType.NUMBER, advance=False):
5953                args = self._parse_csv(self._parse_bitwise)
5954                this.set("start", seq_get(args, 0))
5955                this.set("increment", seq_get(args, 1))
5956
5957            self._match_r_paren()
5958
5959        return this
5960
5961    def _parse_inline(self) -> exp.InlineLengthColumnConstraint:
5962        self._match_text_seq("LENGTH")
5963        return self.expression(exp.InlineLengthColumnConstraint, this=self._parse_bitwise())
5964
5965    def _parse_not_constraint(self) -> t.Optional[exp.Expression]:
5966        if self._match_text_seq("NULL"):
5967            return self.expression(exp.NotNullColumnConstraint)
5968        if self._match_text_seq("CASESPECIFIC"):
5969            return self.expression(exp.CaseSpecificColumnConstraint, not_=True)
5970        if self._match_text_seq("FOR", "REPLICATION"):
5971            return self.expression(exp.NotForReplicationColumnConstraint)
5972
5973        # Unconsume the `NOT` token
5974        self._retreat(self._index - 1)
5975        return None
5976
5977    def _parse_column_constraint(self) -> t.Optional[exp.Expression]:
5978        this = self._match(TokenType.CONSTRAINT) and self._parse_id_var()
5979
5980        procedure_option_follows = (
5981            self._match(TokenType.WITH, advance=False)
5982            and self._next
5983            and self._next.text.upper() in self.PROCEDURE_OPTIONS
5984        )
5985
5986        if not procedure_option_follows and self._match_texts(self.CONSTRAINT_PARSERS):
5987            return self.expression(
5988                exp.ColumnConstraint,
5989                this=this,
5990                kind=self.CONSTRAINT_PARSERS[self._prev.text.upper()](self),
5991            )
5992
5993        return this
5994
5995    def _parse_constraint(self) -> t.Optional[exp.Expression]:
5996        if not self._match(TokenType.CONSTRAINT):
5997            return self._parse_unnamed_constraint(constraints=self.SCHEMA_UNNAMED_CONSTRAINTS)
5998
5999        return self.expression(
6000            exp.Constraint,
6001            this=self._parse_id_var(),
6002            expressions=self._parse_unnamed_constraints(),
6003        )
6004
6005    def _parse_unnamed_constraints(self) -> t.List[exp.Expression]:
6006        constraints = []
6007        while True:
6008            constraint = self._parse_unnamed_constraint() or self._parse_function()
6009            if not constraint:
6010                break
6011            constraints.append(constraint)
6012
6013        return constraints
6014
6015    def _parse_unnamed_constraint(
6016        self, constraints: t.Optional[t.Collection[str]] = None
6017    ) -> t.Optional[exp.Expression]:
6018        if self._match(TokenType.IDENTIFIER, advance=False) or not self._match_texts(
6019            constraints or self.CONSTRAINT_PARSERS
6020        ):
6021            return None
6022
6023        constraint = self._prev.text.upper()
6024        if constraint not in self.CONSTRAINT_PARSERS:
6025            self.raise_error(f"No parser found for schema constraint {constraint}.")
6026
6027        return self.CONSTRAINT_PARSERS[constraint](self)
6028
6029    def _parse_unique_key(self) -> t.Optional[exp.Expression]:
6030        return self._parse_id_var(any_token=False)
6031
6032    def _parse_unique(self) -> exp.UniqueColumnConstraint:
6033        self._match_text_seq("KEY")
6034        return self.expression(
6035            exp.UniqueColumnConstraint,
6036            nulls=self._match_text_seq("NULLS", "NOT", "DISTINCT"),
6037            this=self._parse_schema(self._parse_unique_key()),
6038            index_type=self._match(TokenType.USING) and self._advance_any() and self._prev.text,
6039            on_conflict=self._parse_on_conflict(),
6040            options=self._parse_key_constraint_options(),
6041        )
6042
6043    def _parse_key_constraint_options(self) -> t.List[str]:
6044        options = []
6045        while True:
6046            if not self._curr:
6047                break
6048
6049            if self._match(TokenType.ON):
6050                action = None
6051                on = self._advance_any() and self._prev.text
6052
6053                if self._match_text_seq("NO", "ACTION"):
6054                    action = "NO ACTION"
6055                elif self._match_text_seq("CASCADE"):
6056                    action = "CASCADE"
6057                elif self._match_text_seq("RESTRICT"):
6058                    action = "RESTRICT"
6059                elif self._match_pair(TokenType.SET, TokenType.NULL):
6060                    action = "SET NULL"
6061                elif self._match_pair(TokenType.SET, TokenType.DEFAULT):
6062                    action = "SET DEFAULT"
6063                else:
6064                    self.raise_error("Invalid key constraint")
6065
6066                options.append(f"ON {on} {action}")
6067            else:
6068                var = self._parse_var_from_options(
6069                    self.KEY_CONSTRAINT_OPTIONS, raise_unmatched=False
6070                )
6071                if not var:
6072                    break
6073                options.append(var.name)
6074
6075        return options
6076
6077    def _parse_references(self, match: bool = True) -> t.Optional[exp.Reference]:
6078        if match and not self._match(TokenType.REFERENCES):
6079            return None
6080
6081        expressions = None
6082        this = self._parse_table(schema=True)
6083        options = self._parse_key_constraint_options()
6084        return self.expression(exp.Reference, this=this, expressions=expressions, options=options)
6085
6086    def _parse_foreign_key(self) -> exp.ForeignKey:
6087        expressions = self._parse_wrapped_id_vars()
6088        reference = self._parse_references()
6089        on_options = {}
6090
6091        while self._match(TokenType.ON):
6092            if not self._match_set((TokenType.DELETE, TokenType.UPDATE)):
6093                self.raise_error("Expected DELETE or UPDATE")
6094
6095            kind = self._prev.text.lower()
6096
6097            if self._match_text_seq("NO", "ACTION"):
6098                action = "NO ACTION"
6099            elif self._match(TokenType.SET):
6100                self._match_set((TokenType.NULL, TokenType.DEFAULT))
6101                action = "SET " + self._prev.text.upper()
6102            else:
6103                self._advance()
6104                action = self._prev.text.upper()
6105
6106            on_options[kind] = action
6107
6108        return self.expression(
6109            exp.ForeignKey,
6110            expressions=expressions,
6111            reference=reference,
6112            options=self._parse_key_constraint_options(),
6113            **on_options,  # type: ignore
6114        )
6115
6116    def _parse_primary_key_part(self) -> t.Optional[exp.Expression]:
6117        return self._parse_ordered() or self._parse_field()
6118
6119    def _parse_period_for_system_time(self) -> t.Optional[exp.PeriodForSystemTimeConstraint]:
6120        if not self._match(TokenType.TIMESTAMP_SNAPSHOT):
6121            self._retreat(self._index - 1)
6122            return None
6123
6124        id_vars = self._parse_wrapped_id_vars()
6125        return self.expression(
6126            exp.PeriodForSystemTimeConstraint,
6127            this=seq_get(id_vars, 0),
6128            expression=seq_get(id_vars, 1),
6129        )
6130
6131    def _parse_primary_key(
6132        self, wrapped_optional: bool = False, in_props: bool = False
6133    ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
6134        desc = (
6135            self._match_set((TokenType.ASC, TokenType.DESC))
6136            and self._prev.token_type == TokenType.DESC
6137        )
6138
6139        if not in_props and not self._match(TokenType.L_PAREN, advance=False):
6140            return self.expression(
6141                exp.PrimaryKeyColumnConstraint,
6142                desc=desc,
6143                options=self._parse_key_constraint_options(),
6144            )
6145
6146        expressions = self._parse_wrapped_csv(
6147            self._parse_primary_key_part, optional=wrapped_optional
6148        )
6149        options = self._parse_key_constraint_options()
6150        return self.expression(exp.PrimaryKey, expressions=expressions, options=options)
6151
6152    def _parse_bracket_key_value(self, is_map: bool = False) -> t.Optional[exp.Expression]:
6153        return self._parse_slice(self._parse_alias(self._parse_assignment(), explicit=True))
6154
6155    def _parse_odbc_datetime_literal(self) -> exp.Expression:
6156        """
6157        Parses a datetime column in ODBC format. We parse the column into the corresponding
6158        types, for example `{d'yyyy-mm-dd'}` will be parsed as a `Date` column, exactly the
6159        same as we did for `DATE('yyyy-mm-dd')`.
6160
6161        Reference:
6162        https://learn.microsoft.com/en-us/sql/odbc/reference/develop-app/date-time-and-timestamp-literals
6163        """
6164        self._match(TokenType.VAR)
6165        exp_class = self.ODBC_DATETIME_LITERALS[self._prev.text.lower()]
6166        expression = self.expression(exp_class=exp_class, this=self._parse_string())
6167        if not self._match(TokenType.R_BRACE):
6168            self.raise_error("Expected }")
6169        return expression
6170
6171    def _parse_bracket(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
6172        if not self._match_set((TokenType.L_BRACKET, TokenType.L_BRACE)):
6173            return this
6174
6175        bracket_kind = self._prev.token_type
6176        if (
6177            bracket_kind == TokenType.L_BRACE
6178            and self._curr
6179            and self._curr.token_type == TokenType.VAR
6180            and self._curr.text.lower() in self.ODBC_DATETIME_LITERALS
6181        ):
6182            return self._parse_odbc_datetime_literal()
6183
6184        expressions = self._parse_csv(
6185            lambda: self._parse_bracket_key_value(is_map=bracket_kind == TokenType.L_BRACE)
6186        )
6187
6188        if bracket_kind == TokenType.L_BRACKET and not self._match(TokenType.R_BRACKET):
6189            self.raise_error("Expected ]")
6190        elif bracket_kind == TokenType.L_BRACE and not self._match(TokenType.R_BRACE):
6191            self.raise_error("Expected }")
6192
6193        # https://duckdb.org/docs/sql/data_types/struct.html#creating-structs
6194        if bracket_kind == TokenType.L_BRACE:
6195            this = self.expression(exp.Struct, expressions=self._kv_to_prop_eq(expressions))
6196        elif not this:
6197            this = build_array_constructor(
6198                exp.Array, args=expressions, bracket_kind=bracket_kind, dialect=self.dialect
6199            )
6200        else:
6201            constructor_type = self.ARRAY_CONSTRUCTORS.get(this.name.upper())
6202            if constructor_type:
6203                return build_array_constructor(
6204                    constructor_type,
6205                    args=expressions,
6206                    bracket_kind=bracket_kind,
6207                    dialect=self.dialect,
6208                )
6209
6210            expressions = apply_index_offset(
6211                this, expressions, -self.dialect.INDEX_OFFSET, dialect=self.dialect
6212            )
6213            this = self.expression(exp.Bracket, this=this, expressions=expressions)
6214
6215        self._add_comments(this)
6216        return self._parse_bracket(this)
6217
6218    def _parse_slice(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
6219        if self._match(TokenType.COLON):
6220            return self.expression(exp.Slice, this=this, expression=self._parse_assignment())
6221        return this
6222
6223    def _parse_case(self) -> t.Optional[exp.Expression]:
6224        ifs = []
6225        default = None
6226
6227        comments = self._prev_comments
6228        expression = self._parse_assignment()
6229
6230        while self._match(TokenType.WHEN):
6231            this = self._parse_assignment()
6232            self._match(TokenType.THEN)
6233            then = self._parse_assignment()
6234            ifs.append(self.expression(exp.If, this=this, true=then))
6235
6236        if self._match(TokenType.ELSE):
6237            default = self._parse_assignment()
6238
6239        if not self._match(TokenType.END):
6240            if isinstance(default, exp.Interval) and default.this.sql().upper() == "END":
6241                default = exp.column("interval")
6242            else:
6243                self.raise_error("Expected END after CASE", self._prev)
6244
6245        return self.expression(
6246            exp.Case, comments=comments, this=expression, ifs=ifs, default=default
6247        )
6248
6249    def _parse_if(self) -> t.Optional[exp.Expression]:
6250        if self._match(TokenType.L_PAREN):
6251            args = self._parse_csv(
6252                lambda: self._parse_alias(self._parse_assignment(), explicit=True)
6253            )
6254            this = self.validate_expression(exp.If.from_arg_list(args), args)
6255            self._match_r_paren()
6256        else:
6257            index = self._index - 1
6258
6259            if self.NO_PAREN_IF_COMMANDS and index == 0:
6260                return self._parse_as_command(self._prev)
6261
6262            condition = self._parse_assignment()
6263
6264            if not condition:
6265                self._retreat(index)
6266                return None
6267
6268            self._match(TokenType.THEN)
6269            true = self._parse_assignment()
6270            false = self._parse_assignment() if self._match(TokenType.ELSE) else None
6271            self._match(TokenType.END)
6272            this = self.expression(exp.If, this=condition, true=true, false=false)
6273
6274        return this
6275
6276    def _parse_next_value_for(self) -> t.Optional[exp.Expression]:
6277        if not self._match_text_seq("VALUE", "FOR"):
6278            self._retreat(self._index - 1)
6279            return None
6280
6281        return self.expression(
6282            exp.NextValueFor,
6283            this=self._parse_column(),
6284            order=self._match(TokenType.OVER) and self._parse_wrapped(self._parse_order),
6285        )
6286
6287    def _parse_extract(self) -> exp.Extract | exp.Anonymous:
6288        this = self._parse_function() or self._parse_var_or_string(upper=True)
6289
6290        if self._match(TokenType.FROM):
6291            return self.expression(exp.Extract, this=this, expression=self._parse_bitwise())
6292
6293        if not self._match(TokenType.COMMA):
6294            self.raise_error("Expected FROM or comma after EXTRACT", self._prev)
6295
6296        return self.expression(exp.Extract, this=this, expression=self._parse_bitwise())
6297
6298    def _parse_gap_fill(self) -> exp.GapFill:
6299        self._match(TokenType.TABLE)
6300        this = self._parse_table()
6301
6302        self._match(TokenType.COMMA)
6303        args = [this, *self._parse_csv(self._parse_lambda)]
6304
6305        gap_fill = exp.GapFill.from_arg_list(args)
6306        return self.validate_expression(gap_fill, args)
6307
6308    def _parse_cast(self, strict: bool, safe: t.Optional[bool] = None) -> exp.Expression:
6309        this = self._parse_assignment()
6310
6311        if not self._match(TokenType.ALIAS):
6312            if self._match(TokenType.COMMA):
6313                return self.expression(exp.CastToStrType, this=this, to=self._parse_string())
6314
6315            self.raise_error("Expected AS after CAST")
6316
6317        fmt = None
6318        to = self._parse_types()
6319
6320        default = self._match(TokenType.DEFAULT)
6321        if default:
6322            default = self._parse_bitwise()
6323            self._match_text_seq("ON", "CONVERSION", "ERROR")
6324
6325        if self._match_set((TokenType.FORMAT, TokenType.COMMA)):
6326            fmt_string = self._parse_string()
6327            fmt = self._parse_at_time_zone(fmt_string)
6328
6329            if not to:
6330                to = exp.DataType.build(exp.DataType.Type.UNKNOWN)
6331            if to.this in exp.DataType.TEMPORAL_TYPES:
6332                this = self.expression(
6333                    exp.StrToDate if to.this == exp.DataType.Type.DATE else exp.StrToTime,
6334                    this=this,
6335                    format=exp.Literal.string(
6336                        format_time(
6337                            fmt_string.this if fmt_string else "",
6338                            self.dialect.FORMAT_MAPPING or self.dialect.TIME_MAPPING,
6339                            self.dialect.FORMAT_TRIE or self.dialect.TIME_TRIE,
6340                        )
6341                    ),
6342                    safe=safe,
6343                )
6344
6345                if isinstance(fmt, exp.AtTimeZone) and isinstance(this, exp.StrToTime):
6346                    this.set("zone", fmt.args["zone"])
6347                return this
6348        elif not to:
6349            self.raise_error("Expected TYPE after CAST")
6350        elif isinstance(to, exp.Identifier):
6351            to = exp.DataType.build(to.name, udt=True)
6352        elif to.this == exp.DataType.Type.CHAR:
6353            if self._match(TokenType.CHARACTER_SET):
6354                to = self.expression(exp.CharacterSet, this=self._parse_var_or_string())
6355
6356        return self.expression(
6357            exp.Cast if strict else exp.TryCast,
6358            this=this,
6359            to=to,
6360            format=fmt,
6361            safe=safe,
6362            action=self._parse_var_from_options(self.CAST_ACTIONS, raise_unmatched=False),
6363            default=default,
6364        )
6365
6366    def _parse_string_agg(self) -> exp.GroupConcat:
6367        if self._match(TokenType.DISTINCT):
6368            args: t.List[t.Optional[exp.Expression]] = [
6369                self.expression(exp.Distinct, expressions=[self._parse_assignment()])
6370            ]
6371            if self._match(TokenType.COMMA):
6372                args.extend(self._parse_csv(self._parse_assignment))
6373        else:
6374            args = self._parse_csv(self._parse_assignment)  # type: ignore
6375
6376        if self._match_text_seq("ON", "OVERFLOW"):
6377            # trino: LISTAGG(expression [, separator] [ON OVERFLOW overflow_behavior])
6378            if self._match_text_seq("ERROR"):
6379                on_overflow: t.Optional[exp.Expression] = exp.var("ERROR")
6380            else:
6381                self._match_text_seq("TRUNCATE")
6382                on_overflow = self.expression(
6383                    exp.OverflowTruncateBehavior,
6384                    this=self._parse_string(),
6385                    with_count=(
6386                        self._match_text_seq("WITH", "COUNT")
6387                        or not self._match_text_seq("WITHOUT", "COUNT")
6388                    ),
6389                )
6390        else:
6391            on_overflow = None
6392
6393        index = self._index
6394        if not self._match(TokenType.R_PAREN) and args:
6395            # postgres: STRING_AGG([DISTINCT] expression, separator [ORDER BY expression1 {ASC | DESC} [, ...]])
6396            # bigquery: STRING_AGG([DISTINCT] expression [, separator] [ORDER BY key [{ASC | DESC}] [, ... ]] [LIMIT n])
6397            # The order is parsed through `this` as a canonicalization for WITHIN GROUPs
6398            args[0] = self._parse_limit(this=self._parse_order(this=args[0]))
6399            return self.expression(exp.GroupConcat, this=args[0], separator=seq_get(args, 1))
6400
6401        # Checks if we can parse an order clause: WITHIN GROUP (ORDER BY <order_by_expression_list> [ASC | DESC]).
6402        # This is done "manually", instead of letting _parse_window parse it into an exp.WithinGroup node, so that
6403        # the STRING_AGG call is parsed like in MySQL / SQLite and can thus be transpiled more easily to them.
6404        if not self._match_text_seq("WITHIN", "GROUP"):
6405            self._retreat(index)
6406            return self.validate_expression(exp.GroupConcat.from_arg_list(args), args)
6407
6408        # The corresponding match_r_paren will be called in parse_function (caller)
6409        self._match_l_paren()
6410
6411        return self.expression(
6412            exp.GroupConcat,
6413            this=self._parse_order(this=seq_get(args, 0)),
6414            separator=seq_get(args, 1),
6415            on_overflow=on_overflow,
6416        )
6417
6418    def _parse_convert(
6419        self, strict: bool, safe: t.Optional[bool] = None
6420    ) -> t.Optional[exp.Expression]:
6421        this = self._parse_bitwise()
6422
6423        if self._match(TokenType.USING):
6424            to: t.Optional[exp.Expression] = self.expression(
6425                exp.CharacterSet, this=self._parse_var()
6426            )
6427        elif self._match(TokenType.COMMA):
6428            to = self._parse_types()
6429        else:
6430            to = None
6431
6432        return self.expression(exp.Cast if strict else exp.TryCast, this=this, to=to, safe=safe)
6433
6434    def _parse_xml_table(self) -> exp.XMLTable:
6435        namespaces = None
6436        passing = None
6437        columns = None
6438
6439        if self._match_text_seq("XMLNAMESPACES", "("):
6440            namespaces = self._parse_xml_namespace()
6441            self._match_text_seq(")", ",")
6442
6443        this = self._parse_string()
6444
6445        if self._match_text_seq("PASSING"):
6446            # The BY VALUE keywords are optional and are provided for semantic clarity
6447            self._match_text_seq("BY", "VALUE")
6448            passing = self._parse_csv(self._parse_column)
6449
6450        by_ref = self._match_text_seq("RETURNING", "SEQUENCE", "BY", "REF")
6451
6452        if self._match_text_seq("COLUMNS"):
6453            columns = self._parse_csv(self._parse_field_def)
6454
6455        return self.expression(
6456            exp.XMLTable,
6457            this=this,
6458            namespaces=namespaces,
6459            passing=passing,
6460            columns=columns,
6461            by_ref=by_ref,
6462        )
6463
6464    def _parse_xml_namespace(self) -> t.List[exp.XMLNamespace]:
6465        namespaces = []
6466
6467        while True:
6468            if self._match(TokenType.DEFAULT):
6469                uri = self._parse_string()
6470            else:
6471                uri = self._parse_alias(self._parse_string())
6472            namespaces.append(self.expression(exp.XMLNamespace, this=uri))
6473            if not self._match(TokenType.COMMA):
6474                break
6475
6476        return namespaces
6477
6478    def _parse_decode(self) -> t.Optional[exp.Decode | exp.Case]:
6479        """
6480        There are generally two variants of the DECODE function:
6481
6482        - DECODE(bin, charset)
6483        - DECODE(expression, search, result [, search, result] ... [, default])
6484
6485        The second variant will always be parsed into a CASE expression. Note that NULL
6486        needs special treatment, since we need to explicitly check for it with `IS NULL`,
6487        instead of relying on pattern matching.
6488        """
6489        args = self._parse_csv(self._parse_assignment)
6490
6491        if len(args) < 3:
6492            return self.expression(exp.Decode, this=seq_get(args, 0), charset=seq_get(args, 1))
6493
6494        expression, *expressions = args
6495        if not expression:
6496            return None
6497
6498        ifs = []
6499        for search, result in zip(expressions[::2], expressions[1::2]):
6500            if not search or not result:
6501                return None
6502
6503            if isinstance(search, exp.Literal):
6504                ifs.append(
6505                    exp.If(this=exp.EQ(this=expression.copy(), expression=search), true=result)
6506                )
6507            elif isinstance(search, exp.Null):
6508                ifs.append(
6509                    exp.If(this=exp.Is(this=expression.copy(), expression=exp.Null()), true=result)
6510                )
6511            else:
6512                cond = exp.or_(
6513                    exp.EQ(this=expression.copy(), expression=search),
6514                    exp.and_(
6515                        exp.Is(this=expression.copy(), expression=exp.Null()),
6516                        exp.Is(this=search.copy(), expression=exp.Null()),
6517                        copy=False,
6518                    ),
6519                    copy=False,
6520                )
6521                ifs.append(exp.If(this=cond, true=result))
6522
6523        return exp.Case(ifs=ifs, default=expressions[-1] if len(expressions) % 2 == 1 else None)
6524
6525    def _parse_json_key_value(self) -> t.Optional[exp.JSONKeyValue]:
6526        self._match_text_seq("KEY")
6527        key = self._parse_column()
6528        self._match_set(self.JSON_KEY_VALUE_SEPARATOR_TOKENS)
6529        self._match_text_seq("VALUE")
6530        value = self._parse_bitwise()
6531
6532        if not key and not value:
6533            return None
6534        return self.expression(exp.JSONKeyValue, this=key, expression=value)
6535
6536    def _parse_format_json(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
6537        if not this or not self._match_text_seq("FORMAT", "JSON"):
6538            return this
6539
6540        return self.expression(exp.FormatJson, this=this)
6541
6542    def _parse_on_condition(self) -> t.Optional[exp.OnCondition]:
6543        # MySQL uses "X ON EMPTY Y ON ERROR" (e.g. JSON_VALUE) while Oracle uses the opposite (e.g. JSON_EXISTS)
6544        if self.dialect.ON_CONDITION_EMPTY_BEFORE_ERROR:
6545            empty = self._parse_on_handling("EMPTY", *self.ON_CONDITION_TOKENS)
6546            error = self._parse_on_handling("ERROR", *self.ON_CONDITION_TOKENS)
6547        else:
6548            error = self._parse_on_handling("ERROR", *self.ON_CONDITION_TOKENS)
6549            empty = self._parse_on_handling("EMPTY", *self.ON_CONDITION_TOKENS)
6550
6551        null = self._parse_on_handling("NULL", *self.ON_CONDITION_TOKENS)
6552
6553        if not empty and not error and not null:
6554            return None
6555
6556        return self.expression(
6557            exp.OnCondition,
6558            empty=empty,
6559            error=error,
6560            null=null,
6561        )
6562
6563    def _parse_on_handling(
6564        self, on: str, *values: str
6565    ) -> t.Optional[str] | t.Optional[exp.Expression]:
6566        # Parses the "X ON Y" or "DEFAULT <expr> ON Y syntax, e.g. NULL ON NULL (Oracle, T-SQL, MySQL)
6567        for value in values:
6568            if self._match_text_seq(value, "ON", on):
6569                return f"{value} ON {on}"
6570
6571        index = self._index
6572        if self._match(TokenType.DEFAULT):
6573            default_value = self._parse_bitwise()
6574            if self._match_text_seq("ON", on):
6575                return default_value
6576
6577            self._retreat(index)
6578
6579        return None
6580
6581    @t.overload
6582    def _parse_json_object(self, agg: Lit[False]) -> exp.JSONObject: ...
6583
6584    @t.overload
6585    def _parse_json_object(self, agg: Lit[True]) -> exp.JSONObjectAgg: ...
6586
6587    def _parse_json_object(self, agg=False):
6588        star = self._parse_star()
6589        expressions = (
6590            [star]
6591            if star
6592            else self._parse_csv(lambda: self._parse_format_json(self._parse_json_key_value()))
6593        )
6594        null_handling = self._parse_on_handling("NULL", "NULL", "ABSENT")
6595
6596        unique_keys = None
6597        if self._match_text_seq("WITH", "UNIQUE"):
6598            unique_keys = True
6599        elif self._match_text_seq("WITHOUT", "UNIQUE"):
6600            unique_keys = False
6601
6602        self._match_text_seq("KEYS")
6603
6604        return_type = self._match_text_seq("RETURNING") and self._parse_format_json(
6605            self._parse_type()
6606        )
6607        encoding = self._match_text_seq("ENCODING") and self._parse_var()
6608
6609        return self.expression(
6610            exp.JSONObjectAgg if agg else exp.JSONObject,
6611            expressions=expressions,
6612            null_handling=null_handling,
6613            unique_keys=unique_keys,
6614            return_type=return_type,
6615            encoding=encoding,
6616        )
6617
6618    # Note: this is currently incomplete; it only implements the "JSON_value_column" part
6619    def _parse_json_column_def(self) -> exp.JSONColumnDef:
6620        if not self._match_text_seq("NESTED"):
6621            this = self._parse_id_var()
6622            kind = self._parse_types(allow_identifiers=False)
6623            nested = None
6624        else:
6625            this = None
6626            kind = None
6627            nested = True
6628
6629        path = self._match_text_seq("PATH") and self._parse_string()
6630        nested_schema = nested and self._parse_json_schema()
6631
6632        return self.expression(
6633            exp.JSONColumnDef,
6634            this=this,
6635            kind=kind,
6636            path=path,
6637            nested_schema=nested_schema,
6638        )
6639
6640    def _parse_json_schema(self) -> exp.JSONSchema:
6641        self._match_text_seq("COLUMNS")
6642        return self.expression(
6643            exp.JSONSchema,
6644            expressions=self._parse_wrapped_csv(self._parse_json_column_def, optional=True),
6645        )
6646
6647    def _parse_json_table(self) -> exp.JSONTable:
6648        this = self._parse_format_json(self._parse_bitwise())
6649        path = self._match(TokenType.COMMA) and self._parse_string()
6650        error_handling = self._parse_on_handling("ERROR", "ERROR", "NULL")
6651        empty_handling = self._parse_on_handling("EMPTY", "ERROR", "NULL")
6652        schema = self._parse_json_schema()
6653
6654        return exp.JSONTable(
6655            this=this,
6656            schema=schema,
6657            path=path,
6658            error_handling=error_handling,
6659            empty_handling=empty_handling,
6660        )
6661
6662    def _parse_match_against(self) -> exp.MatchAgainst:
6663        expressions = self._parse_csv(self._parse_column)
6664
6665        self._match_text_seq(")", "AGAINST", "(")
6666
6667        this = self._parse_string()
6668
6669        if self._match_text_seq("IN", "NATURAL", "LANGUAGE", "MODE"):
6670            modifier = "IN NATURAL LANGUAGE MODE"
6671            if self._match_text_seq("WITH", "QUERY", "EXPANSION"):
6672                modifier = f"{modifier} WITH QUERY EXPANSION"
6673        elif self._match_text_seq("IN", "BOOLEAN", "MODE"):
6674            modifier = "IN BOOLEAN MODE"
6675        elif self._match_text_seq("WITH", "QUERY", "EXPANSION"):
6676            modifier = "WITH QUERY EXPANSION"
6677        else:
6678            modifier = None
6679
6680        return self.expression(
6681            exp.MatchAgainst, this=this, expressions=expressions, modifier=modifier
6682        )
6683
6684    # https://learn.microsoft.com/en-us/sql/t-sql/functions/openjson-transact-sql?view=sql-server-ver16
6685    def _parse_open_json(self) -> exp.OpenJSON:
6686        this = self._parse_bitwise()
6687        path = self._match(TokenType.COMMA) and self._parse_string()
6688
6689        def _parse_open_json_column_def() -> exp.OpenJSONColumnDef:
6690            this = self._parse_field(any_token=True)
6691            kind = self._parse_types()
6692            path = self._parse_string()
6693            as_json = self._match_pair(TokenType.ALIAS, TokenType.JSON)
6694
6695            return self.expression(
6696                exp.OpenJSONColumnDef, this=this, kind=kind, path=path, as_json=as_json
6697            )
6698
6699        expressions = None
6700        if self._match_pair(TokenType.R_PAREN, TokenType.WITH):
6701            self._match_l_paren()
6702            expressions = self._parse_csv(_parse_open_json_column_def)
6703
6704        return self.expression(exp.OpenJSON, this=this, path=path, expressions=expressions)
6705
6706    def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
6707        args = self._parse_csv(self._parse_bitwise)
6708
6709        if self._match(TokenType.IN):
6710            return self.expression(
6711                exp.StrPosition, this=self._parse_bitwise(), substr=seq_get(args, 0)
6712            )
6713
6714        if haystack_first:
6715            haystack = seq_get(args, 0)
6716            needle = seq_get(args, 1)
6717        else:
6718            haystack = seq_get(args, 1)
6719            needle = seq_get(args, 0)
6720
6721        return self.expression(
6722            exp.StrPosition, this=haystack, substr=needle, position=seq_get(args, 2)
6723        )
6724
6725    def _parse_predict(self) -> exp.Predict:
6726        self._match_text_seq("MODEL")
6727        this = self._parse_table()
6728
6729        self._match(TokenType.COMMA)
6730        self._match_text_seq("TABLE")
6731
6732        return self.expression(
6733            exp.Predict,
6734            this=this,
6735            expression=self._parse_table(),
6736            params_struct=self._match(TokenType.COMMA) and self._parse_bitwise(),
6737        )
6738
6739    def _parse_join_hint(self, func_name: str) -> exp.JoinHint:
6740        args = self._parse_csv(self._parse_table)
6741        return exp.JoinHint(this=func_name.upper(), expressions=args)
6742
6743    def _parse_substring(self) -> exp.Substring:
6744        # Postgres supports the form: substring(string [from int] [for int])
6745        # https://www.postgresql.org/docs/9.1/functions-string.html @ Table 9-6
6746
6747        args = t.cast(t.List[t.Optional[exp.Expression]], self._parse_csv(self._parse_bitwise))
6748
6749        if self._match(TokenType.FROM):
6750            args.append(self._parse_bitwise())
6751        if self._match(TokenType.FOR):
6752            if len(args) == 1:
6753                args.append(exp.Literal.number(1))
6754            args.append(self._parse_bitwise())
6755
6756        return self.validate_expression(exp.Substring.from_arg_list(args), args)
6757
6758    def _parse_trim(self) -> exp.Trim:
6759        # https://www.w3resource.com/sql/character-functions/trim.php
6760        # https://docs.oracle.com/javadb/10.8.3.0/ref/rreftrimfunc.html
6761
6762        position = None
6763        collation = None
6764        expression = None
6765
6766        if self._match_texts(self.TRIM_TYPES):
6767            position = self._prev.text.upper()
6768
6769        this = self._parse_bitwise()
6770        if self._match_set((TokenType.FROM, TokenType.COMMA)):
6771            invert_order = self._prev.token_type == TokenType.FROM or self.TRIM_PATTERN_FIRST
6772            expression = self._parse_bitwise()
6773
6774            if invert_order:
6775                this, expression = expression, this
6776
6777        if self._match(TokenType.COLLATE):
6778            collation = self._parse_bitwise()
6779
6780        return self.expression(
6781            exp.Trim, this=this, position=position, expression=expression, collation=collation
6782        )
6783
6784    def _parse_window_clause(self) -> t.Optional[t.List[exp.Expression]]:
6785        return self._match(TokenType.WINDOW) and self._parse_csv(self._parse_named_window)
6786
6787    def _parse_named_window(self) -> t.Optional[exp.Expression]:
6788        return self._parse_window(self._parse_id_var(), alias=True)
6789
6790    def _parse_respect_or_ignore_nulls(
6791        self, this: t.Optional[exp.Expression]
6792    ) -> t.Optional[exp.Expression]:
6793        if self._match_text_seq("IGNORE", "NULLS"):
6794            return self.expression(exp.IgnoreNulls, this=this)
6795        if self._match_text_seq("RESPECT", "NULLS"):
6796            return self.expression(exp.RespectNulls, this=this)
6797        return this
6798
6799    def _parse_having_max(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
6800        if self._match(TokenType.HAVING):
6801            self._match_texts(("MAX", "MIN"))
6802            max = self._prev.text.upper() != "MIN"
6803            return self.expression(
6804                exp.HavingMax, this=this, expression=self._parse_column(), max=max
6805            )
6806
6807        return this
6808
6809    def _parse_window(
6810        self, this: t.Optional[exp.Expression], alias: bool = False
6811    ) -> t.Optional[exp.Expression]:
6812        func = this
6813        comments = func.comments if isinstance(func, exp.Expression) else None
6814
6815        # T-SQL allows the OVER (...) syntax after WITHIN GROUP.
6816        # https://learn.microsoft.com/en-us/sql/t-sql/functions/percentile-disc-transact-sql?view=sql-server-ver16
6817        if self._match_text_seq("WITHIN", "GROUP"):
6818            order = self._parse_wrapped(self._parse_order)
6819            this = self.expression(exp.WithinGroup, this=this, expression=order)
6820
6821        if self._match_pair(TokenType.FILTER, TokenType.L_PAREN):
6822            self._match(TokenType.WHERE)
6823            this = self.expression(
6824                exp.Filter, this=this, expression=self._parse_where(skip_where_token=True)
6825            )
6826            self._match_r_paren()
6827
6828        # SQL spec defines an optional [ { IGNORE | RESPECT } NULLS ] OVER
6829        # Some dialects choose to implement and some do not.
6830        # https://dev.mysql.com/doc/refman/8.0/en/window-function-descriptions.html
6831
6832        # There is some code above in _parse_lambda that handles
6833        #   SELECT FIRST_VALUE(TABLE.COLUMN IGNORE|RESPECT NULLS) OVER ...
6834
6835        # The below changes handle
6836        #   SELECT FIRST_VALUE(TABLE.COLUMN) IGNORE|RESPECT NULLS OVER ...
6837
6838        # Oracle allows both formats
6839        #   (https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/img_text/first_value.html)
6840        #   and Snowflake chose to do the same for familiarity
6841        #   https://docs.snowflake.com/en/sql-reference/functions/first_value.html#usage-notes
6842        if isinstance(this, exp.AggFunc):
6843            ignore_respect = this.find(exp.IgnoreNulls, exp.RespectNulls)
6844
6845            if ignore_respect and ignore_respect is not this:
6846                ignore_respect.replace(ignore_respect.this)
6847                this = self.expression(ignore_respect.__class__, this=this)
6848
6849        this = self._parse_respect_or_ignore_nulls(this)
6850
6851        # bigquery select from window x AS (partition by ...)
6852        if alias:
6853            over = None
6854            self._match(TokenType.ALIAS)
6855        elif not self._match_set(self.WINDOW_BEFORE_PAREN_TOKENS):
6856            return this
6857        else:
6858            over = self._prev.text.upper()
6859
6860        if comments and isinstance(func, exp.Expression):
6861            func.pop_comments()
6862
6863        if not self._match(TokenType.L_PAREN):
6864            return self.expression(
6865                exp.Window,
6866                comments=comments,
6867                this=this,
6868                alias=self._parse_id_var(False),
6869                over=over,
6870            )
6871
6872        window_alias = self._parse_id_var(any_token=False, tokens=self.WINDOW_ALIAS_TOKENS)
6873
6874        first = self._match(TokenType.FIRST)
6875        if self._match_text_seq("LAST"):
6876            first = False
6877
6878        partition, order = self._parse_partition_and_order()
6879        kind = self._match_set((TokenType.ROWS, TokenType.RANGE)) and self._prev.text
6880
6881        if kind:
6882            self._match(TokenType.BETWEEN)
6883            start = self._parse_window_spec()
6884            self._match(TokenType.AND)
6885            end = self._parse_window_spec()
6886
6887            spec = self.expression(
6888                exp.WindowSpec,
6889                kind=kind,
6890                start=start["value"],
6891                start_side=start["side"],
6892                end=end["value"],
6893                end_side=end["side"],
6894            )
6895        else:
6896            spec = None
6897
6898        self._match_r_paren()
6899
6900        window = self.expression(
6901            exp.Window,
6902            comments=comments,
6903            this=this,
6904            partition_by=partition,
6905            order=order,
6906            spec=spec,
6907            alias=window_alias,
6908            over=over,
6909            first=first,
6910        )
6911
6912        # This covers Oracle's FIRST/LAST syntax: aggregate KEEP (...) OVER (...)
6913        if self._match_set(self.WINDOW_BEFORE_PAREN_TOKENS, advance=False):
6914            return self._parse_window(window, alias=alias)
6915
6916        return window
6917
6918    def _parse_partition_and_order(
6919        self,
6920    ) -> t.Tuple[t.List[exp.Expression], t.Optional[exp.Expression]]:
6921        return self._parse_partition_by(), self._parse_order()
6922
6923    def _parse_window_spec(self) -> t.Dict[str, t.Optional[str | exp.Expression]]:
6924        self._match(TokenType.BETWEEN)
6925
6926        return {
6927            "value": (
6928                (self._match_text_seq("UNBOUNDED") and "UNBOUNDED")
6929                or (self._match_text_seq("CURRENT", "ROW") and "CURRENT ROW")
6930                or self._parse_bitwise()
6931            ),
6932            "side": self._match_texts(self.WINDOW_SIDES) and self._prev.text,
6933        }
6934
6935    def _parse_alias(
6936        self, this: t.Optional[exp.Expression], explicit: bool = False
6937    ) -> t.Optional[exp.Expression]:
6938        # In some dialects, LIMIT and OFFSET can act as both identifiers and keywords (clauses)
6939        # so this section tries to parse the clause version and if it fails, it treats the token
6940        # as an identifier (alias)
6941        if self._can_parse_limit_or_offset():
6942            return this
6943
6944        any_token = self._match(TokenType.ALIAS)
6945        comments = self._prev_comments or []
6946
6947        if explicit and not any_token:
6948            return this
6949
6950        if self._match(TokenType.L_PAREN):
6951            aliases = self.expression(
6952                exp.Aliases,
6953                comments=comments,
6954                this=this,
6955                expressions=self._parse_csv(lambda: self._parse_id_var(any_token)),
6956            )
6957            self._match_r_paren(aliases)
6958            return aliases
6959
6960        alias = self._parse_id_var(any_token, tokens=self.ALIAS_TOKENS) or (
6961            self.STRING_ALIASES and self._parse_string_as_identifier()
6962        )
6963
6964        if alias:
6965            comments.extend(alias.pop_comments())
6966            this = self.expression(exp.Alias, comments=comments, this=this, alias=alias)
6967            column = this.this
6968
6969            # Moves the comment next to the alias in `expr /* comment */ AS alias`
6970            if not this.comments and column and column.comments:
6971                this.comments = column.pop_comments()
6972
6973        return this
6974
6975    def _parse_id_var(
6976        self,
6977        any_token: bool = True,
6978        tokens: t.Optional[t.Collection[TokenType]] = None,
6979    ) -> t.Optional[exp.Expression]:
6980        expression = self._parse_identifier()
6981        if not expression and (
6982            (any_token and self._advance_any()) or self._match_set(tokens or self.ID_VAR_TOKENS)
6983        ):
6984            quoted = self._prev.token_type == TokenType.STRING
6985            expression = self._identifier_expression(quoted=quoted)
6986
6987        return expression
6988
6989    def _parse_string(self) -> t.Optional[exp.Expression]:
6990        if self._match_set(self.STRING_PARSERS):
6991            return self.STRING_PARSERS[self._prev.token_type](self, self._prev)
6992        return self._parse_placeholder()
6993
6994    def _parse_string_as_identifier(self) -> t.Optional[exp.Identifier]:
6995        output = exp.to_identifier(self._match(TokenType.STRING) and self._prev.text, quoted=True)
6996        if output:
6997            output.update_positions(self._prev)
6998        return output
6999
7000    def _parse_number(self) -> t.Optional[exp.Expression]:
7001        if self._match_set(self.NUMERIC_PARSERS):
7002            return self.NUMERIC_PARSERS[self._prev.token_type](self, self._prev)
7003        return self._parse_placeholder()
7004
7005    def _parse_identifier(self) -> t.Optional[exp.Expression]:
7006        if self._match(TokenType.IDENTIFIER):
7007            return self._identifier_expression(quoted=True)
7008        return self._parse_placeholder()
7009
7010    def _parse_var(
7011        self,
7012        any_token: bool = False,
7013        tokens: t.Optional[t.Collection[TokenType]] = None,
7014        upper: bool = False,
7015    ) -> t.Optional[exp.Expression]:
7016        if (
7017            (any_token and self._advance_any())
7018            or self._match(TokenType.VAR)
7019            or (self._match_set(tokens) if tokens else False)
7020        ):
7021            return self.expression(
7022                exp.Var, this=self._prev.text.upper() if upper else self._prev.text
7023            )
7024        return self._parse_placeholder()
7025
7026    def _advance_any(self, ignore_reserved: bool = False) -> t.Optional[Token]:
7027        if self._curr and (ignore_reserved or self._curr.token_type not in self.RESERVED_TOKENS):
7028            self._advance()
7029            return self._prev
7030        return None
7031
7032    def _parse_var_or_string(self, upper: bool = False) -> t.Optional[exp.Expression]:
7033        return self._parse_string() or self._parse_var(any_token=True, upper=upper)
7034
7035    def _parse_primary_or_var(self) -> t.Optional[exp.Expression]:
7036        return self._parse_primary() or self._parse_var(any_token=True)
7037
7038    def _parse_null(self) -> t.Optional[exp.Expression]:
7039        if self._match_set(self.NULL_TOKENS):
7040            return self.PRIMARY_PARSERS[TokenType.NULL](self, self._prev)
7041        return self._parse_placeholder()
7042
7043    def _parse_boolean(self) -> t.Optional[exp.Expression]:
7044        if self._match(TokenType.TRUE):
7045            return self.PRIMARY_PARSERS[TokenType.TRUE](self, self._prev)
7046        if self._match(TokenType.FALSE):
7047            return self.PRIMARY_PARSERS[TokenType.FALSE](self, self._prev)
7048        return self._parse_placeholder()
7049
7050    def _parse_star(self) -> t.Optional[exp.Expression]:
7051        if self._match(TokenType.STAR):
7052            return self.PRIMARY_PARSERS[TokenType.STAR](self, self._prev)
7053        return self._parse_placeholder()
7054
7055    def _parse_parameter(self) -> exp.Parameter:
7056        this = self._parse_identifier() or self._parse_primary_or_var()
7057        return self.expression(exp.Parameter, this=this)
7058
7059    def _parse_placeholder(self) -> t.Optional[exp.Expression]:
7060        if self._match_set(self.PLACEHOLDER_PARSERS):
7061            placeholder = self.PLACEHOLDER_PARSERS[self._prev.token_type](self)
7062            if placeholder:
7063                return placeholder
7064            self._advance(-1)
7065        return None
7066
7067    def _parse_star_op(self, *keywords: str) -> t.Optional[t.List[exp.Expression]]:
7068        if not self._match_texts(keywords):
7069            return None
7070        if self._match(TokenType.L_PAREN, advance=False):
7071            return self._parse_wrapped_csv(self._parse_expression)
7072
7073        expression = self._parse_expression()
7074        return [expression] if expression else None
7075
7076    def _parse_csv(
7077        self, parse_method: t.Callable, sep: TokenType = TokenType.COMMA
7078    ) -> t.List[exp.Expression]:
7079        parse_result = parse_method()
7080        items = [parse_result] if parse_result is not None else []
7081
7082        while self._match(sep):
7083            self._add_comments(parse_result)
7084            parse_result = parse_method()
7085            if parse_result is not None:
7086                items.append(parse_result)
7087
7088        return items
7089
7090    def _parse_tokens(
7091        self, parse_method: t.Callable, expressions: t.Dict
7092    ) -> t.Optional[exp.Expression]:
7093        this = parse_method()
7094
7095        while self._match_set(expressions):
7096            this = self.expression(
7097                expressions[self._prev.token_type],
7098                this=this,
7099                comments=self._prev_comments,
7100                expression=parse_method(),
7101            )
7102
7103        return this
7104
7105    def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
7106        return self._parse_wrapped_csv(self._parse_id_var, optional=optional)
7107
7108    def _parse_wrapped_csv(
7109        self, parse_method: t.Callable, sep: TokenType = TokenType.COMMA, optional: bool = False
7110    ) -> t.List[exp.Expression]:
7111        return self._parse_wrapped(
7112            lambda: self._parse_csv(parse_method, sep=sep), optional=optional
7113        )
7114
7115    def _parse_wrapped(self, parse_method: t.Callable, optional: bool = False) -> t.Any:
7116        wrapped = self._match(TokenType.L_PAREN)
7117        if not wrapped and not optional:
7118            self.raise_error("Expecting (")
7119        parse_result = parse_method()
7120        if wrapped:
7121            self._match_r_paren()
7122        return parse_result
7123
7124    def _parse_expressions(self) -> t.List[exp.Expression]:
7125        return self._parse_csv(self._parse_expression)
7126
7127    def _parse_select_or_expression(self, alias: bool = False) -> t.Optional[exp.Expression]:
7128        return self._parse_select() or self._parse_set_operations(
7129            self._parse_alias(self._parse_assignment(), explicit=True)
7130            if alias
7131            else self._parse_assignment()
7132        )
7133
7134    def _parse_ddl_select(self) -> t.Optional[exp.Expression]:
7135        return self._parse_query_modifiers(
7136            self._parse_set_operations(self._parse_select(nested=True, parse_subquery_alias=False))
7137        )
7138
7139    def _parse_transaction(self) -> exp.Transaction | exp.Command:
7140        this = None
7141        if self._match_texts(self.TRANSACTION_KIND):
7142            this = self._prev.text
7143
7144        self._match_texts(("TRANSACTION", "WORK"))
7145
7146        modes = []
7147        while True:
7148            mode = []
7149            while self._match(TokenType.VAR):
7150                mode.append(self._prev.text)
7151
7152            if mode:
7153                modes.append(" ".join(mode))
7154            if not self._match(TokenType.COMMA):
7155                break
7156
7157        return self.expression(exp.Transaction, this=this, modes=modes)
7158
7159    def _parse_commit_or_rollback(self) -> exp.Commit | exp.Rollback:
7160        chain = None
7161        savepoint = None
7162        is_rollback = self._prev.token_type == TokenType.ROLLBACK
7163
7164        self._match_texts(("TRANSACTION", "WORK"))
7165
7166        if self._match_text_seq("TO"):
7167            self._match_text_seq("SAVEPOINT")
7168            savepoint = self._parse_id_var()
7169
7170        if self._match(TokenType.AND):
7171            chain = not self._match_text_seq("NO")
7172            self._match_text_seq("CHAIN")
7173
7174        if is_rollback:
7175            return self.expression(exp.Rollback, savepoint=savepoint)
7176
7177        return self.expression(exp.Commit, chain=chain)
7178
7179    def _parse_refresh(self) -> exp.Refresh:
7180        self._match(TokenType.TABLE)
7181        return self.expression(exp.Refresh, this=self._parse_string() or self._parse_table())
7182
7183    def _parse_add_column(self) -> t.Optional[exp.Expression]:
7184        if not self._match_text_seq("ADD"):
7185            return None
7186
7187        self._match(TokenType.COLUMN)
7188        exists_column = self._parse_exists(not_=True)
7189        expression = self._parse_field_def()
7190
7191        if expression:
7192            expression.set("exists", exists_column)
7193
7194            # https://docs.databricks.com/delta/update-schema.html#explicitly-update-schema-to-add-columns
7195            if self._match_texts(("FIRST", "AFTER")):
7196                position = self._prev.text
7197                column_position = self.expression(
7198                    exp.ColumnPosition, this=self._parse_column(), position=position
7199                )
7200                expression.set("position", column_position)
7201
7202        return expression
7203
7204    def _parse_drop_column(self) -> t.Optional[exp.Drop | exp.Command]:
7205        drop = self._match(TokenType.DROP) and self._parse_drop()
7206        if drop and not isinstance(drop, exp.Command):
7207            drop.set("kind", drop.args.get("kind", "COLUMN"))
7208        return drop
7209
7210    # https://docs.aws.amazon.com/athena/latest/ug/alter-table-drop-partition.html
7211    def _parse_drop_partition(self, exists: t.Optional[bool] = None) -> exp.DropPartition:
7212        return self.expression(
7213            exp.DropPartition, expressions=self._parse_csv(self._parse_partition), exists=exists
7214        )
7215
7216    def _parse_alter_table_add(self) -> t.List[exp.Expression]:
7217        index = self._index - 1
7218
7219        if self._match_set(self.ADD_CONSTRAINT_TOKENS, advance=False):
7220            return self._parse_csv(
7221                lambda: self.expression(
7222                    exp.AddConstraint, expressions=self._parse_csv(self._parse_constraint)
7223                )
7224            )
7225
7226        self._retreat(index)
7227        if not self.ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN and self._match_text_seq("ADD"):
7228            return self._parse_wrapped_csv(self._parse_field_def, optional=True)
7229
7230        if self._match_text_seq("ADD", "COLUMNS"):
7231            schema = self._parse_schema()
7232            if schema:
7233                return [schema]
7234            return []
7235
7236        return self._parse_wrapped_csv(self._parse_add_column, optional=True)
7237
7238    def _parse_alter_table_alter(self) -> t.Optional[exp.Expression]:
7239        if self._match_texts(self.ALTER_ALTER_PARSERS):
7240            return self.ALTER_ALTER_PARSERS[self._prev.text.upper()](self)
7241
7242        # Many dialects support the ALTER [COLUMN] syntax, so if there is no
7243        # keyword after ALTER we default to parsing this statement
7244        self._match(TokenType.COLUMN)
7245        column = self._parse_field(any_token=True)
7246
7247        if self._match_pair(TokenType.DROP, TokenType.DEFAULT):
7248            return self.expression(exp.AlterColumn, this=column, drop=True)
7249        if self._match_pair(TokenType.SET, TokenType.DEFAULT):
7250            return self.expression(exp.AlterColumn, this=column, default=self._parse_assignment())
7251        if self._match(TokenType.COMMENT):
7252            return self.expression(exp.AlterColumn, this=column, comment=self._parse_string())
7253        if self._match_text_seq("DROP", "NOT", "NULL"):
7254            return self.expression(
7255                exp.AlterColumn,
7256                this=column,
7257                drop=True,
7258                allow_null=True,
7259            )
7260        if self._match_text_seq("SET", "NOT", "NULL"):
7261            return self.expression(
7262                exp.AlterColumn,
7263                this=column,
7264                allow_null=False,
7265            )
7266
7267        if self._match_text_seq("SET", "VISIBLE"):
7268            return self.expression(exp.AlterColumn, this=column, visible="VISIBLE")
7269        if self._match_text_seq("SET", "INVISIBLE"):
7270            return self.expression(exp.AlterColumn, this=column, visible="INVISIBLE")
7271
7272        self._match_text_seq("SET", "DATA")
7273        self._match_text_seq("TYPE")
7274        return self.expression(
7275            exp.AlterColumn,
7276            this=column,
7277            dtype=self._parse_types(),
7278            collate=self._match(TokenType.COLLATE) and self._parse_term(),
7279            using=self._match(TokenType.USING) and self._parse_assignment(),
7280        )
7281
7282    def _parse_alter_diststyle(self) -> exp.AlterDistStyle:
7283        if self._match_texts(("ALL", "EVEN", "AUTO")):
7284            return self.expression(exp.AlterDistStyle, this=exp.var(self._prev.text.upper()))
7285
7286        self._match_text_seq("KEY", "DISTKEY")
7287        return self.expression(exp.AlterDistStyle, this=self._parse_column())
7288
7289    def _parse_alter_sortkey(self, compound: t.Optional[bool] = None) -> exp.AlterSortKey:
7290        if compound:
7291            self._match_text_seq("SORTKEY")
7292
7293        if self._match(TokenType.L_PAREN, advance=False):
7294            return self.expression(
7295                exp.AlterSortKey, expressions=self._parse_wrapped_id_vars(), compound=compound
7296            )
7297
7298        self._match_texts(("AUTO", "NONE"))
7299        return self.expression(
7300            exp.AlterSortKey, this=exp.var(self._prev.text.upper()), compound=compound
7301        )
7302
7303    def _parse_alter_table_drop(self) -> t.List[exp.Expression]:
7304        index = self._index - 1
7305
7306        partition_exists = self._parse_exists()
7307        if self._match(TokenType.PARTITION, advance=False):
7308            return self._parse_csv(lambda: self._parse_drop_partition(exists=partition_exists))
7309
7310        self._retreat(index)
7311        return self._parse_csv(self._parse_drop_column)
7312
7313    def _parse_alter_table_rename(self) -> t.Optional[exp.AlterRename | exp.RenameColumn]:
7314        if self._match(TokenType.COLUMN):
7315            exists = self._parse_exists()
7316            old_column = self._parse_column()
7317            to = self._match_text_seq("TO")
7318            new_column = self._parse_column()
7319
7320            if old_column is None or to is None or new_column is None:
7321                return None
7322
7323            return self.expression(exp.RenameColumn, this=old_column, to=new_column, exists=exists)
7324
7325        self._match_text_seq("TO")
7326        return self.expression(exp.AlterRename, this=self._parse_table(schema=True))
7327
7328    def _parse_alter_table_set(self) -> exp.AlterSet:
7329        alter_set = self.expression(exp.AlterSet)
7330
7331        if self._match(TokenType.L_PAREN, advance=False) or self._match_text_seq(
7332            "TABLE", "PROPERTIES"
7333        ):
7334            alter_set.set("expressions", self._parse_wrapped_csv(self._parse_assignment))
7335        elif self._match_text_seq("FILESTREAM_ON", advance=False):
7336            alter_set.set("expressions", [self._parse_assignment()])
7337        elif self._match_texts(("LOGGED", "UNLOGGED")):
7338            alter_set.set("option", exp.var(self._prev.text.upper()))
7339        elif self._match_text_seq("WITHOUT") and self._match_texts(("CLUSTER", "OIDS")):
7340            alter_set.set("option", exp.var(f"WITHOUT {self._prev.text.upper()}"))
7341        elif self._match_text_seq("LOCATION"):
7342            alter_set.set("location", self._parse_field())
7343        elif self._match_text_seq("ACCESS", "METHOD"):
7344            alter_set.set("access_method", self._parse_field())
7345        elif self._match_text_seq("TABLESPACE"):
7346            alter_set.set("tablespace", self._parse_field())
7347        elif self._match_text_seq("FILE", "FORMAT") or self._match_text_seq("FILEFORMAT"):
7348            alter_set.set("file_format", [self._parse_field()])
7349        elif self._match_text_seq("STAGE_FILE_FORMAT"):
7350            alter_set.set("file_format", self._parse_wrapped_options())
7351        elif self._match_text_seq("STAGE_COPY_OPTIONS"):
7352            alter_set.set("copy_options", self._parse_wrapped_options())
7353        elif self._match_text_seq("TAG") or self._match_text_seq("TAGS"):
7354            alter_set.set("tag", self._parse_csv(self._parse_assignment))
7355        else:
7356            if self._match_text_seq("SERDE"):
7357                alter_set.set("serde", self._parse_field())
7358
7359            alter_set.set("expressions", [self._parse_properties()])
7360
7361        return alter_set
7362
7363    def _parse_alter(self) -> exp.Alter | exp.Command:
7364        start = self._prev
7365
7366        alter_token = self._match_set(self.ALTERABLES) and self._prev
7367        if not alter_token:
7368            return self._parse_as_command(start)
7369
7370        exists = self._parse_exists()
7371        only = self._match_text_seq("ONLY")
7372        this = self._parse_table(schema=True)
7373        cluster = self._parse_on_property() if self._match(TokenType.ON) else None
7374
7375        if self._next:
7376            self._advance()
7377
7378        parser = self.ALTER_PARSERS.get(self._prev.text.upper()) if self._prev else None
7379        if parser:
7380            actions = ensure_list(parser(self))
7381            not_valid = self._match_text_seq("NOT", "VALID")
7382            options = self._parse_csv(self._parse_property)
7383
7384            if not self._curr and actions:
7385                return self.expression(
7386                    exp.Alter,
7387                    this=this,
7388                    kind=alter_token.text.upper(),
7389                    exists=exists,
7390                    actions=actions,
7391                    only=only,
7392                    options=options,
7393                    cluster=cluster,
7394                    not_valid=not_valid,
7395                )
7396
7397        return self._parse_as_command(start)
7398
7399    def _parse_analyze(self) -> exp.Analyze | exp.Command:
7400        start = self._prev
7401        # https://duckdb.org/docs/sql/statements/analyze
7402        if not self._curr:
7403            return self.expression(exp.Analyze)
7404
7405        options = []
7406        while self._match_texts(self.ANALYZE_STYLES):
7407            if self._prev.text.upper() == "BUFFER_USAGE_LIMIT":
7408                options.append(f"BUFFER_USAGE_LIMIT {self._parse_number()}")
7409            else:
7410                options.append(self._prev.text.upper())
7411
7412        this: t.Optional[exp.Expression] = None
7413        inner_expression: t.Optional[exp.Expression] = None
7414
7415        kind = self._curr and self._curr.text.upper()
7416
7417        if self._match(TokenType.TABLE) or self._match(TokenType.INDEX):
7418            this = self._parse_table_parts()
7419        elif self._match_text_seq("TABLES"):
7420            if self._match_set((TokenType.FROM, TokenType.IN)):
7421                kind = f"{kind} {self._prev.text.upper()}"
7422                this = self._parse_table(schema=True, is_db_reference=True)
7423        elif self._match_text_seq("DATABASE"):
7424            this = self._parse_table(schema=True, is_db_reference=True)
7425        elif self._match_text_seq("CLUSTER"):
7426            this = self._parse_table()
7427        # Try matching inner expr keywords before fallback to parse table.
7428        elif self._match_texts(self.ANALYZE_EXPRESSION_PARSERS):
7429            kind = None
7430            inner_expression = self.ANALYZE_EXPRESSION_PARSERS[self._prev.text.upper()](self)
7431        else:
7432            # Empty kind  https://prestodb.io/docs/current/sql/analyze.html
7433            kind = None
7434            this = self._parse_table_parts()
7435
7436        partition = self._try_parse(self._parse_partition)
7437        if not partition and self._match_texts(self.PARTITION_KEYWORDS):
7438            return self._parse_as_command(start)
7439
7440        # https://docs.starrocks.io/docs/sql-reference/sql-statements/cbo_stats/ANALYZE_TABLE/
7441        if self._match_text_seq("WITH", "SYNC", "MODE") or self._match_text_seq(
7442            "WITH", "ASYNC", "MODE"
7443        ):
7444            mode = f"WITH {self._tokens[self._index - 2].text.upper()} MODE"
7445        else:
7446            mode = None
7447
7448        if self._match_texts(self.ANALYZE_EXPRESSION_PARSERS):
7449            inner_expression = self.ANALYZE_EXPRESSION_PARSERS[self._prev.text.upper()](self)
7450
7451        properties = self._parse_properties()
7452        return self.expression(
7453            exp.Analyze,
7454            kind=kind,
7455            this=this,
7456            mode=mode,
7457            partition=partition,
7458            properties=properties,
7459            expression=inner_expression,
7460            options=options,
7461        )
7462
7463    # https://spark.apache.org/docs/3.5.1/sql-ref-syntax-aux-analyze-table.html
7464    def _parse_analyze_statistics(self) -> exp.AnalyzeStatistics:
7465        this = None
7466        kind = self._prev.text.upper()
7467        option = self._prev.text.upper() if self._match_text_seq("DELTA") else None
7468        expressions = []
7469
7470        if not self._match_text_seq("STATISTICS"):
7471            self.raise_error("Expecting token STATISTICS")
7472
7473        if self._match_text_seq("NOSCAN"):
7474            this = "NOSCAN"
7475        elif self._match(TokenType.FOR):
7476            if self._match_text_seq("ALL", "COLUMNS"):
7477                this = "FOR ALL COLUMNS"
7478            if self._match_texts("COLUMNS"):
7479                this = "FOR COLUMNS"
7480                expressions = self._parse_csv(self._parse_column_reference)
7481        elif self._match_text_seq("SAMPLE"):
7482            sample = self._parse_number()
7483            expressions = [
7484                self.expression(
7485                    exp.AnalyzeSample,
7486                    sample=sample,
7487                    kind=self._prev.text.upper() if self._match(TokenType.PERCENT) else None,
7488                )
7489            ]
7490
7491        return self.expression(
7492            exp.AnalyzeStatistics, kind=kind, option=option, this=this, expressions=expressions
7493        )
7494
7495    # https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ANALYZE.html
7496    def _parse_analyze_validate(self) -> exp.AnalyzeValidate:
7497        kind = None
7498        this = None
7499        expression: t.Optional[exp.Expression] = None
7500        if self._match_text_seq("REF", "UPDATE"):
7501            kind = "REF"
7502            this = "UPDATE"
7503            if self._match_text_seq("SET", "DANGLING", "TO", "NULL"):
7504                this = "UPDATE SET DANGLING TO NULL"
7505        elif self._match_text_seq("STRUCTURE"):
7506            kind = "STRUCTURE"
7507            if self._match_text_seq("CASCADE", "FAST"):
7508                this = "CASCADE FAST"
7509            elif self._match_text_seq("CASCADE", "COMPLETE") and self._match_texts(
7510                ("ONLINE", "OFFLINE")
7511            ):
7512                this = f"CASCADE COMPLETE {self._prev.text.upper()}"
7513                expression = self._parse_into()
7514
7515        return self.expression(exp.AnalyzeValidate, kind=kind, this=this, expression=expression)
7516
7517    def _parse_analyze_columns(self) -> t.Optional[exp.AnalyzeColumns]:
7518        this = self._prev.text.upper()
7519        if self._match_text_seq("COLUMNS"):
7520            return self.expression(exp.AnalyzeColumns, this=f"{this} {self._prev.text.upper()}")
7521        return None
7522
7523    def _parse_analyze_delete(self) -> t.Optional[exp.AnalyzeDelete]:
7524        kind = self._prev.text.upper() if self._match_text_seq("SYSTEM") else None
7525        if self._match_text_seq("STATISTICS"):
7526            return self.expression(exp.AnalyzeDelete, kind=kind)
7527        return None
7528
7529    def _parse_analyze_list(self) -> t.Optional[exp.AnalyzeListChainedRows]:
7530        if self._match_text_seq("CHAINED", "ROWS"):
7531            return self.expression(exp.AnalyzeListChainedRows, expression=self._parse_into())
7532        return None
7533
7534    # https://dev.mysql.com/doc/refman/8.4/en/analyze-table.html
7535    def _parse_analyze_histogram(self) -> exp.AnalyzeHistogram:
7536        this = self._prev.text.upper()
7537        expression: t.Optional[exp.Expression] = None
7538        expressions = []
7539        update_options = None
7540
7541        if self._match_text_seq("HISTOGRAM", "ON"):
7542            expressions = self._parse_csv(self._parse_column_reference)
7543            with_expressions = []
7544            while self._match(TokenType.WITH):
7545                # https://docs.starrocks.io/docs/sql-reference/sql-statements/cbo_stats/ANALYZE_TABLE/
7546                if self._match_texts(("SYNC", "ASYNC")):
7547                    if self._match_text_seq("MODE", advance=False):
7548                        with_expressions.append(f"{self._prev.text.upper()} MODE")
7549                        self._advance()
7550                else:
7551                    buckets = self._parse_number()
7552                    if self._match_text_seq("BUCKETS"):
7553                        with_expressions.append(f"{buckets} BUCKETS")
7554            if with_expressions:
7555                expression = self.expression(exp.AnalyzeWith, expressions=with_expressions)
7556
7557            if self._match_texts(("MANUAL", "AUTO")) and self._match(
7558                TokenType.UPDATE, advance=False
7559            ):
7560                update_options = self._prev.text.upper()
7561                self._advance()
7562            elif self._match_text_seq("USING", "DATA"):
7563                expression = self.expression(exp.UsingData, this=self._parse_string())
7564
7565        return self.expression(
7566            exp.AnalyzeHistogram,
7567            this=this,
7568            expressions=expressions,
7569            expression=expression,
7570            update_options=update_options,
7571        )
7572
7573    def _parse_merge(self) -> exp.Merge:
7574        self._match(TokenType.INTO)
7575        target = self._parse_table()
7576
7577        if target and self._match(TokenType.ALIAS, advance=False):
7578            target.set("alias", self._parse_table_alias())
7579
7580        self._match(TokenType.USING)
7581        using = self._parse_table()
7582
7583        self._match(TokenType.ON)
7584        on = self._parse_assignment()
7585
7586        return self.expression(
7587            exp.Merge,
7588            this=target,
7589            using=using,
7590            on=on,
7591            whens=self._parse_when_matched(),
7592            returning=self._parse_returning(),
7593        )
7594
7595    def _parse_when_matched(self) -> exp.Whens:
7596        whens = []
7597
7598        while self._match(TokenType.WHEN):
7599            matched = not self._match(TokenType.NOT)
7600            self._match_text_seq("MATCHED")
7601            source = (
7602                False
7603                if self._match_text_seq("BY", "TARGET")
7604                else self._match_text_seq("BY", "SOURCE")
7605            )
7606            condition = self._parse_assignment() if self._match(TokenType.AND) else None
7607
7608            self._match(TokenType.THEN)
7609
7610            if self._match(TokenType.INSERT):
7611                this = self._parse_star()
7612                if this:
7613                    then: t.Optional[exp.Expression] = self.expression(exp.Insert, this=this)
7614                else:
7615                    then = self.expression(
7616                        exp.Insert,
7617                        this=exp.var("ROW")
7618                        if self._match_text_seq("ROW")
7619                        else self._parse_value(values=False),
7620                        expression=self._match_text_seq("VALUES") and self._parse_value(),
7621                    )
7622            elif self._match(TokenType.UPDATE):
7623                expressions = self._parse_star()
7624                if expressions:
7625                    then = self.expression(exp.Update, expressions=expressions)
7626                else:
7627                    then = self.expression(
7628                        exp.Update,
7629                        expressions=self._match(TokenType.SET)
7630                        and self._parse_csv(self._parse_equality),
7631                    )
7632            elif self._match(TokenType.DELETE):
7633                then = self.expression(exp.Var, this=self._prev.text)
7634            else:
7635                then = self._parse_var_from_options(self.CONFLICT_ACTIONS)
7636
7637            whens.append(
7638                self.expression(
7639                    exp.When,
7640                    matched=matched,
7641                    source=source,
7642                    condition=condition,
7643                    then=then,
7644                )
7645            )
7646        return self.expression(exp.Whens, expressions=whens)
7647
7648    def _parse_show(self) -> t.Optional[exp.Expression]:
7649        parser = self._find_parser(self.SHOW_PARSERS, self.SHOW_TRIE)
7650        if parser:
7651            return parser(self)
7652        return self._parse_as_command(self._prev)
7653
7654    def _parse_set_item_assignment(
7655        self, kind: t.Optional[str] = None
7656    ) -> t.Optional[exp.Expression]:
7657        index = self._index
7658
7659        if kind in ("GLOBAL", "SESSION") and self._match_text_seq("TRANSACTION"):
7660            return self._parse_set_transaction(global_=kind == "GLOBAL")
7661
7662        left = self._parse_primary() or self._parse_column()
7663        assignment_delimiter = self._match_texts(("=", "TO"))
7664
7665        if not left or (self.SET_REQUIRES_ASSIGNMENT_DELIMITER and not assignment_delimiter):
7666            self._retreat(index)
7667            return None
7668
7669        right = self._parse_statement() or self._parse_id_var()
7670        if isinstance(right, (exp.Column, exp.Identifier)):
7671            right = exp.var(right.name)
7672
7673        this = self.expression(exp.EQ, this=left, expression=right)
7674        return self.expression(exp.SetItem, this=this, kind=kind)
7675
7676    def _parse_set_transaction(self, global_: bool = False) -> exp.Expression:
7677        self._match_text_seq("TRANSACTION")
7678        characteristics = self._parse_csv(
7679            lambda: self._parse_var_from_options(self.TRANSACTION_CHARACTERISTICS)
7680        )
7681        return self.expression(
7682            exp.SetItem,
7683            expressions=characteristics,
7684            kind="TRANSACTION",
7685            **{"global": global_},  # type: ignore
7686        )
7687
7688    def _parse_set_item(self) -> t.Optional[exp.Expression]:
7689        parser = self._find_parser(self.SET_PARSERS, self.SET_TRIE)
7690        return parser(self) if parser else self._parse_set_item_assignment(kind=None)
7691
7692    def _parse_set(self, unset: bool = False, tag: bool = False) -> exp.Set | exp.Command:
7693        index = self._index
7694        set_ = self.expression(
7695            exp.Set, expressions=self._parse_csv(self._parse_set_item), unset=unset, tag=tag
7696        )
7697
7698        if self._curr:
7699            self._retreat(index)
7700            return self._parse_as_command(self._prev)
7701
7702        return set_
7703
7704    def _parse_var_from_options(
7705        self, options: OPTIONS_TYPE, raise_unmatched: bool = True
7706    ) -> t.Optional[exp.Var]:
7707        start = self._curr
7708        if not start:
7709            return None
7710
7711        option = start.text.upper()
7712        continuations = options.get(option)
7713
7714        index = self._index
7715        self._advance()
7716        for keywords in continuations or []:
7717            if isinstance(keywords, str):
7718                keywords = (keywords,)
7719
7720            if self._match_text_seq(*keywords):
7721                option = f"{option} {' '.join(keywords)}"
7722                break
7723        else:
7724            if continuations or continuations is None:
7725                if raise_unmatched:
7726                    self.raise_error(f"Unknown option {option}")
7727
7728                self._retreat(index)
7729                return None
7730
7731        return exp.var(option)
7732
7733    def _parse_as_command(self, start: Token) -> exp.Command:
7734        while self._curr:
7735            self._advance()
7736        text = self._find_sql(start, self._prev)
7737        size = len(start.text)
7738        self._warn_unsupported()
7739        return exp.Command(this=text[:size], expression=text[size:])
7740
7741    def _parse_dict_property(self, this: str) -> exp.DictProperty:
7742        settings = []
7743
7744        self._match_l_paren()
7745        kind = self._parse_id_var()
7746
7747        if self._match(TokenType.L_PAREN):
7748            while True:
7749                key = self._parse_id_var()
7750                value = self._parse_primary()
7751                if not key and value is None:
7752                    break
7753                settings.append(self.expression(exp.DictSubProperty, this=key, value=value))
7754            self._match(TokenType.R_PAREN)
7755
7756        self._match_r_paren()
7757
7758        return self.expression(
7759            exp.DictProperty,
7760            this=this,
7761            kind=kind.this if kind else None,
7762            settings=settings,
7763        )
7764
7765    def _parse_dict_range(self, this: str) -> exp.DictRange:
7766        self._match_l_paren()
7767        has_min = self._match_text_seq("MIN")
7768        if has_min:
7769            min = self._parse_var() or self._parse_primary()
7770            self._match_text_seq("MAX")
7771            max = self._parse_var() or self._parse_primary()
7772        else:
7773            max = self._parse_var() or self._parse_primary()
7774            min = exp.Literal.number(0)
7775        self._match_r_paren()
7776        return self.expression(exp.DictRange, this=this, min=min, max=max)
7777
7778    def _parse_comprehension(
7779        self, this: t.Optional[exp.Expression]
7780    ) -> t.Optional[exp.Comprehension]:
7781        index = self._index
7782        expression = self._parse_column()
7783        if not self._match(TokenType.IN):
7784            self._retreat(index - 1)
7785            return None
7786        iterator = self._parse_column()
7787        condition = self._parse_assignment() if self._match_text_seq("IF") else None
7788        return self.expression(
7789            exp.Comprehension,
7790            this=this,
7791            expression=expression,
7792            iterator=iterator,
7793            condition=condition,
7794        )
7795
7796    def _parse_heredoc(self) -> t.Optional[exp.Heredoc]:
7797        if self._match(TokenType.HEREDOC_STRING):
7798            return self.expression(exp.Heredoc, this=self._prev.text)
7799
7800        if not self._match_text_seq("$"):
7801            return None
7802
7803        tags = ["$"]
7804        tag_text = None
7805
7806        if self._is_connected():
7807            self._advance()
7808            tags.append(self._prev.text.upper())
7809        else:
7810            self.raise_error("No closing $ found")
7811
7812        if tags[-1] != "$":
7813            if self._is_connected() and self._match_text_seq("$"):
7814                tag_text = tags[-1]
7815                tags.append("$")
7816            else:
7817                self.raise_error("No closing $ found")
7818
7819        heredoc_start = self._curr
7820
7821        while self._curr:
7822            if self._match_text_seq(*tags, advance=False):
7823                this = self._find_sql(heredoc_start, self._prev)
7824                self._advance(len(tags))
7825                return self.expression(exp.Heredoc, this=this, tag=tag_text)
7826
7827            self._advance()
7828
7829        self.raise_error(f"No closing {''.join(tags)} found")
7830        return None
7831
7832    def _find_parser(
7833        self, parsers: t.Dict[str, t.Callable], trie: t.Dict
7834    ) -> t.Optional[t.Callable]:
7835        if not self._curr:
7836            return None
7837
7838        index = self._index
7839        this = []
7840        while True:
7841            # The current token might be multiple words
7842            curr = self._curr.text.upper()
7843            key = curr.split(" ")
7844            this.append(curr)
7845
7846            self._advance()
7847            result, trie = in_trie(trie, key)
7848            if result == TrieResult.FAILED:
7849                break
7850
7851            if result == TrieResult.EXISTS:
7852                subparser = parsers[" ".join(this)]
7853                return subparser
7854
7855        self._retreat(index)
7856        return None
7857
7858    def _match(self, token_type, advance=True, expression=None):
7859        if not self._curr:
7860            return None
7861
7862        if self._curr.token_type == token_type:
7863            if advance:
7864                self._advance()
7865            self._add_comments(expression)
7866            return True
7867
7868        return None
7869
7870    def _match_set(self, types, advance=True):
7871        if not self._curr:
7872            return None
7873
7874        if self._curr.token_type in types:
7875            if advance:
7876                self._advance()
7877            return True
7878
7879        return None
7880
7881    def _match_pair(self, token_type_a, token_type_b, advance=True):
7882        if not self._curr or not self._next:
7883            return None
7884
7885        if self._curr.token_type == token_type_a and self._next.token_type == token_type_b:
7886            if advance:
7887                self._advance(2)
7888            return True
7889
7890        return None
7891
7892    def _match_l_paren(self, expression: t.Optional[exp.Expression] = None) -> None:
7893        if not self._match(TokenType.L_PAREN, expression=expression):
7894            self.raise_error("Expecting (")
7895
7896    def _match_r_paren(self, expression: t.Optional[exp.Expression] = None) -> None:
7897        if not self._match(TokenType.R_PAREN, expression=expression):
7898            self.raise_error("Expecting )")
7899
7900    def _match_texts(self, texts, advance=True):
7901        if (
7902            self._curr
7903            and self._curr.token_type != TokenType.STRING
7904            and self._curr.text.upper() in texts
7905        ):
7906            if advance:
7907                self._advance()
7908            return True
7909        return None
7910
7911    def _match_text_seq(self, *texts, advance=True):
7912        index = self._index
7913        for text in texts:
7914            if (
7915                self._curr
7916                and self._curr.token_type != TokenType.STRING
7917                and self._curr.text.upper() == text
7918            ):
7919                self._advance()
7920            else:
7921                self._retreat(index)
7922                return None
7923
7924        if not advance:
7925            self._retreat(index)
7926
7927        return True
7928
7929    def _replace_lambda(
7930        self, node: t.Optional[exp.Expression], expressions: t.List[exp.Expression]
7931    ) -> t.Optional[exp.Expression]:
7932        if not node:
7933            return node
7934
7935        lambda_types = {e.name: e.args.get("to") or False for e in expressions}
7936
7937        for column in node.find_all(exp.Column):
7938            typ = lambda_types.get(column.parts[0].name)
7939            if typ is not None:
7940                dot_or_id = column.to_dot() if column.table else column.this
7941
7942                if typ:
7943                    dot_or_id = self.expression(
7944                        exp.Cast,
7945                        this=dot_or_id,
7946                        to=typ,
7947                    )
7948
7949                parent = column.parent
7950
7951                while isinstance(parent, exp.Dot):
7952                    if not isinstance(parent.parent, exp.Dot):
7953                        parent.replace(dot_or_id)
7954                        break
7955                    parent = parent.parent
7956                else:
7957                    if column is node:
7958                        node = dot_or_id
7959                    else:
7960                        column.replace(dot_or_id)
7961        return node
7962
7963    def _parse_truncate_table(self) -> t.Optional[exp.TruncateTable] | exp.Expression:
7964        start = self._prev
7965
7966        # Not to be confused with TRUNCATE(number, decimals) function call
7967        if self._match(TokenType.L_PAREN):
7968            self._retreat(self._index - 2)
7969            return self._parse_function()
7970
7971        # Clickhouse supports TRUNCATE DATABASE as well
7972        is_database = self._match(TokenType.DATABASE)
7973
7974        self._match(TokenType.TABLE)
7975
7976        exists = self._parse_exists(not_=False)
7977
7978        expressions = self._parse_csv(
7979            lambda: self._parse_table(schema=True, is_db_reference=is_database)
7980        )
7981
7982        cluster = self._parse_on_property() if self._match(TokenType.ON) else None
7983
7984        if self._match_text_seq("RESTART", "IDENTITY"):
7985            identity = "RESTART"
7986        elif self._match_text_seq("CONTINUE", "IDENTITY"):
7987            identity = "CONTINUE"
7988        else:
7989            identity = None
7990
7991        if self._match_text_seq("CASCADE") or self._match_text_seq("RESTRICT"):
7992            option = self._prev.text
7993        else:
7994            option = None
7995
7996        partition = self._parse_partition()
7997
7998        # Fallback case
7999        if self._curr:
8000            return self._parse_as_command(start)
8001
8002        return self.expression(
8003            exp.TruncateTable,
8004            expressions=expressions,
8005            is_database=is_database,
8006            exists=exists,
8007            cluster=cluster,
8008            identity=identity,
8009            option=option,
8010            partition=partition,
8011        )
8012
8013    def _parse_with_operator(self) -> t.Optional[exp.Expression]:
8014        this = self._parse_ordered(self._parse_opclass)
8015
8016        if not self._match(TokenType.WITH):
8017            return this
8018
8019        op = self._parse_var(any_token=True)
8020
8021        return self.expression(exp.WithOperator, this=this, op=op)
8022
8023    def _parse_wrapped_options(self) -> t.List[t.Optional[exp.Expression]]:
8024        self._match(TokenType.EQ)
8025        self._match(TokenType.L_PAREN)
8026
8027        opts: t.List[t.Optional[exp.Expression]] = []
8028        option: exp.Expression | None
8029        while self._curr and not self._match(TokenType.R_PAREN):
8030            if self._match_text_seq("FORMAT_NAME", "="):
8031                # The FORMAT_NAME can be set to an identifier for Snowflake and T-SQL
8032                option = self._parse_format_name()
8033            else:
8034                option = self._parse_property()
8035
8036            if option is None:
8037                self.raise_error("Unable to parse option")
8038                break
8039
8040            opts.append(option)
8041
8042        return opts
8043
8044    def _parse_copy_parameters(self) -> t.List[exp.CopyParameter]:
8045        sep = TokenType.COMMA if self.dialect.COPY_PARAMS_ARE_CSV else None
8046
8047        options = []
8048        while self._curr and not self._match(TokenType.R_PAREN, advance=False):
8049            option = self._parse_var(any_token=True)
8050            prev = self._prev.text.upper()
8051
8052            # Different dialects might separate options and values by white space, "=" and "AS"
8053            self._match(TokenType.EQ)
8054            self._match(TokenType.ALIAS)
8055
8056            param = self.expression(exp.CopyParameter, this=option)
8057
8058            if prev in self.COPY_INTO_VARLEN_OPTIONS and self._match(
8059                TokenType.L_PAREN, advance=False
8060            ):
8061                # Snowflake FILE_FORMAT case, Databricks COPY & FORMAT options
8062                param.set("expressions", self._parse_wrapped_options())
8063            elif prev == "FILE_FORMAT":
8064                # T-SQL's external file format case
8065                param.set("expression", self._parse_field())
8066            else:
8067                param.set("expression", self._parse_unquoted_field())
8068
8069            options.append(param)
8070            self._match(sep)
8071
8072        return options
8073
8074    def _parse_credentials(self) -> t.Optional[exp.Credentials]:
8075        expr = self.expression(exp.Credentials)
8076
8077        if self._match_text_seq("STORAGE_INTEGRATION", "="):
8078            expr.set("storage", self._parse_field())
8079        if self._match_text_seq("CREDENTIALS"):
8080            # Snowflake case: CREDENTIALS = (...), Redshift case: CREDENTIALS <string>
8081            creds = (
8082                self._parse_wrapped_options() if self._match(TokenType.EQ) else self._parse_field()
8083            )
8084            expr.set("credentials", creds)
8085        if self._match_text_seq("ENCRYPTION"):
8086            expr.set("encryption", self._parse_wrapped_options())
8087        if self._match_text_seq("IAM_ROLE"):
8088            expr.set("iam_role", self._parse_field())
8089        if self._match_text_seq("REGION"):
8090            expr.set("region", self._parse_field())
8091
8092        return expr
8093
8094    def _parse_file_location(self) -> t.Optional[exp.Expression]:
8095        return self._parse_field()
8096
8097    def _parse_copy(self) -> exp.Copy | exp.Command:
8098        start = self._prev
8099
8100        self._match(TokenType.INTO)
8101
8102        this = (
8103            self._parse_select(nested=True, parse_subquery_alias=False)
8104            if self._match(TokenType.L_PAREN, advance=False)
8105            else self._parse_table(schema=True)
8106        )
8107
8108        kind = self._match(TokenType.FROM) or not self._match_text_seq("TO")
8109
8110        files = self._parse_csv(self._parse_file_location)
8111        credentials = self._parse_credentials()
8112
8113        self._match_text_seq("WITH")
8114
8115        params = self._parse_wrapped(self._parse_copy_parameters, optional=True)
8116
8117        # Fallback case
8118        if self._curr:
8119            return self._parse_as_command(start)
8120
8121        return self.expression(
8122            exp.Copy,
8123            this=this,
8124            kind=kind,
8125            credentials=credentials,
8126            files=files,
8127            params=params,
8128        )
8129
8130    def _parse_normalize(self) -> exp.Normalize:
8131        return self.expression(
8132            exp.Normalize,
8133            this=self._parse_bitwise(),
8134            form=self._match(TokenType.COMMA) and self._parse_var(),
8135        )
8136
8137    def _parse_ceil_floor(self, expr_type: t.Type[TCeilFloor]) -> TCeilFloor:
8138        args = self._parse_csv(lambda: self._parse_lambda())
8139
8140        this = seq_get(args, 0)
8141        decimals = seq_get(args, 1)
8142
8143        return expr_type(
8144            this=this, decimals=decimals, to=self._match_text_seq("TO") and self._parse_var()
8145        )
8146
8147    def _parse_star_ops(self) -> t.Optional[exp.Expression]:
8148        if self._match_text_seq("COLUMNS", "(", advance=False):
8149            this = self._parse_function()
8150            if isinstance(this, exp.Columns):
8151                this.set("unpack", True)
8152            return this
8153
8154        return self.expression(
8155            exp.Star,
8156            **{  # type: ignore
8157                "except": self._parse_star_op("EXCEPT", "EXCLUDE"),
8158                "replace": self._parse_star_op("REPLACE"),
8159                "rename": self._parse_star_op("RENAME"),
8160            },
8161        )
8162
8163    def _parse_grant_privilege(self) -> t.Optional[exp.GrantPrivilege]:
8164        privilege_parts = []
8165
8166        # Keep consuming consecutive keywords until comma (end of this privilege) or ON
8167        # (end of privilege list) or L_PAREN (start of column list) are met
8168        while self._curr and not self._match_set(self.PRIVILEGE_FOLLOW_TOKENS, advance=False):
8169            privilege_parts.append(self._curr.text.upper())
8170            self._advance()
8171
8172        this = exp.var(" ".join(privilege_parts))
8173        expressions = (
8174            self._parse_wrapped_csv(self._parse_column)
8175            if self._match(TokenType.L_PAREN, advance=False)
8176            else None
8177        )
8178
8179        return self.expression(exp.GrantPrivilege, this=this, expressions=expressions)
8180
8181    def _parse_grant_principal(self) -> t.Optional[exp.GrantPrincipal]:
8182        kind = self._match_texts(("ROLE", "GROUP")) and self._prev.text.upper()
8183        principal = self._parse_id_var()
8184
8185        if not principal:
8186            return None
8187
8188        return self.expression(exp.GrantPrincipal, this=principal, kind=kind)
8189
8190    def _parse_grant(self) -> exp.Grant | exp.Command:
8191        start = self._prev
8192
8193        privileges = self._parse_csv(self._parse_grant_privilege)
8194
8195        self._match(TokenType.ON)
8196        kind = self._match_set(self.CREATABLES) and self._prev.text.upper()
8197
8198        # Attempt to parse the securable e.g. MySQL allows names
8199        # such as "foo.*", "*.*" which are not easily parseable yet
8200        securable = self._try_parse(self._parse_table_parts)
8201
8202        if not securable or not self._match_text_seq("TO"):
8203            return self._parse_as_command(start)
8204
8205        principals = self._parse_csv(self._parse_grant_principal)
8206
8207        grant_option = self._match_text_seq("WITH", "GRANT", "OPTION")
8208
8209        if self._curr:
8210            return self._parse_as_command(start)
8211
8212        return self.expression(
8213            exp.Grant,
8214            privileges=privileges,
8215            kind=kind,
8216            securable=securable,
8217            principals=principals,
8218            grant_option=grant_option,
8219        )
8220
8221    def _parse_overlay(self) -> exp.Overlay:
8222        return self.expression(
8223            exp.Overlay,
8224            **{  # type: ignore
8225                "this": self._parse_bitwise(),
8226                "expression": self._match_text_seq("PLACING") and self._parse_bitwise(),
8227                "from": self._match_text_seq("FROM") and self._parse_bitwise(),
8228                "for": self._match_text_seq("FOR") and self._parse_bitwise(),
8229            },
8230        )
8231
8232    def _parse_format_name(self) -> exp.Property:
8233        # Note: Although not specified in the docs, Snowflake does accept a string/identifier
8234        # for FILE_FORMAT = <format_name>
8235        return self.expression(
8236            exp.Property,
8237            this=exp.var("FORMAT_NAME"),
8238            value=self._parse_string() or self._parse_table_parts(),
8239        )
8240
8241    def _parse_max_min_by(self, expr_type: t.Type[exp.AggFunc]) -> exp.AggFunc:
8242        args: t.List[exp.Expression] = []
8243
8244        if self._match(TokenType.DISTINCT):
8245            args.append(self.expression(exp.Distinct, expressions=[self._parse_assignment()]))
8246            self._match(TokenType.COMMA)
8247
8248        args.extend(self._parse_csv(self._parse_assignment))
8249
8250        return self.expression(
8251            expr_type, this=seq_get(args, 0), expression=seq_get(args, 1), count=seq_get(args, 2)
8252        )
8253
8254    def _identifier_expression(
8255        self, token: t.Optional[Token] = None, **kwargs: t.Any
8256    ) -> exp.Identifier:
8257        token = token or self._prev
8258        expression = self.expression(exp.Identifier, this=token.text, **kwargs)
8259        expression.update_positions(token)
8260        return expression