sqlglot.parser

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