sqlglot.parsers.snowflake

   1from __future__ import annotations
   2
   3import typing as t
   4
   5from sqlglot import exp, parser
   6from sqlglot.dialects.dialect import (
   7    Dialect,
   8    binary_from_function,
   9    build_default_decimal_type,
  10    build_formatted_time,
  11    build_like,
  12    build_replace_with_optional_replacement,
  13    build_timetostr_or_tochar,
  14    build_trunc,
  15    date_trunc_to_time,
  16    map_date_part,
  17)
  18from sqlglot.helper import is_int, seq_get
  19from sqlglot.tokens import TokenType
  20from sqlglot.trie import new_trie
  21
  22if t.TYPE_CHECKING:
  23    from collections.abc import Collection
  24
  25    from sqlglot._typing import B, E
  26    from sqlglot.dialects.dialect import Dialect
  27
  28
  29def _build_approx_top_k(args: list) -> exp.ApproxTopK:
  30    """
  31    Normalizes APPROX_TOP_K arguments to match Snowflake semantics.
  32
  33    Snowflake APPROX_TOP_K signature: APPROX_TOP_K(column [, k] [, counters])
  34    - k defaults to 1 if omitted (per Snowflake documentation)
  35    - counters is optional precision parameter
  36    """
  37    # Add default k=1 if only column is provided
  38    if len(args) == 1:
  39        args.append(exp.Literal.number(1))
  40
  41    return exp.ApproxTopK.from_arg_list(args)
  42
  43
  44def _build_to_number(args: list, safe: bool = False) -> exp.ToNumber:
  45    second_arg = seq_get(args, 1)
  46    if second_arg and second_arg.is_number:
  47        fmt = None
  48        precision = second_arg
  49        scale = seq_get(args, 2) or exp.Literal.number(0)
  50    else:
  51        fmt = second_arg
  52        precision = seq_get(args, 2) or exp.Literal.number(38)
  53        scale = seq_get(args, 3) or exp.Literal.number(0)
  54
  55    return exp.ToNumber(
  56        this=seq_get(args, 0),
  57        format=fmt,
  58        precision=precision,
  59        scale=scale,
  60        safe=safe,
  61    )
  62
  63
  64def _build_date_from_parts(args: list) -> exp.DateFromParts:
  65    return exp.DateFromParts(
  66        year=seq_get(args, 0),
  67        month=seq_get(args, 1),
  68        day=seq_get(args, 2),
  69        allow_overflow=True,
  70    )
  71
  72
  73# Timestamp types used in _build_datetime
  74TIMESTAMP_TYPES = {
  75    exp.DType.TIMESTAMP: "TO_TIMESTAMP",
  76    exp.DType.TIMESTAMPLTZ: "TO_TIMESTAMP_LTZ",
  77    exp.DType.TIMESTAMPNTZ: "TO_TIMESTAMP_NTZ",
  78    exp.DType.TIMESTAMPTZ: "TO_TIMESTAMP_TZ",
  79}
  80
  81
  82def _build_datetime(name: str, kind: exp.DType, safe: bool = False) -> t.Callable:
  83    def _builder(args: list, dialect: Dialect) -> exp.Func:
  84        value = seq_get(args, 0)
  85        scale_or_fmt = seq_get(args, 1)
  86
  87        int_value = value is not None and is_int(value.name)
  88        int_scale_or_fmt = scale_or_fmt is not None and scale_or_fmt.is_int
  89
  90        if isinstance(value, (exp.Literal, exp.Neg)) or (value and scale_or_fmt):
  91            # Converts calls like `TO_TIME('01:02:03')` into casts
  92            if len(args) == 1 and value.is_string and not int_value:
  93                cast = (
  94                    exp.TryCast(this=value, to=kind.into_expr(), requires_string=True)
  95                    if safe
  96                    else exp.cast(value, kind)
  97                )
  98                if safe and kind == exp.DType.DATE:
  99                    cast.set("probe_date_format", True)
 100                return cast
 101
 102            # Handles `TO_TIMESTAMP(str, fmt)` and `TO_TIMESTAMP(num, scale)` as special
 103            # cases so we can transpile them, since they're relatively common
 104            if kind in TIMESTAMP_TYPES:
 105                if not safe and (int_scale_or_fmt or (int_value and scale_or_fmt is None)):
 106                    # TRY_TO_TIMESTAMP('integer') is not parsed into exp.UnixToTime as
 107                    # it's not easily transpilable. Also, numeric-looking strings with
 108                    # format strings (e.g., TO_TIMESTAMP('20240115', 'YYYYMMDD')) should
 109                    # use StrToTime, not UnixToTime.
 110                    unix_expr = exp.UnixToTime(this=value, scale=scale_or_fmt)
 111                    unix_expr.set("target_type", kind.into_expr())
 112                    return unix_expr
 113                if scale_or_fmt and not int_scale_or_fmt:
 114                    # Format string provided (e.g., 'YYYY-MM-DD'), use StrToTime
 115                    strtotime_expr = build_formatted_time(exp.StrToTime)(args, dialect)
 116                    strtotime_expr.set("safe", safe)
 117                    strtotime_expr.set("target_type", kind.into_expr())
 118                    return strtotime_expr
 119
 120        # Handle DATE/TIME with format strings - allow int_value if a format string is provided
 121        has_format_string = scale_or_fmt and not int_scale_or_fmt
 122        if kind in (exp.DType.DATE, exp.DType.TIME) and (not int_value or has_format_string):
 123            klass = exp.TsOrDsToDate if kind == exp.DType.DATE else exp.TsOrDsToTime
 124            formatted_exp = build_formatted_time(klass)(args, dialect)
 125            formatted_exp.set("safe", safe)
 126            return formatted_exp
 127
 128        return exp.Anonymous(this=name, expressions=args)
 129
 130    return _builder
 131
 132
 133def _build_bitwise(expr_type: type[B], name: str) -> t.Callable[[list], B | exp.Anonymous]:
 134    def _builder(args: list) -> B | exp.Anonymous:
 135        if len(args) == 3:
 136            # Special handling for bitwise operations with padside argument
 137            if expr_type in (exp.BitwiseAnd, exp.BitwiseOr, exp.BitwiseXor):
 138                return expr_type(
 139                    this=seq_get(args, 0), expression=seq_get(args, 1), padside=seq_get(args, 2)
 140                )
 141            return exp.Anonymous(this=name, expressions=args)
 142
 143        result = binary_from_function(expr_type)(args)
 144
 145        # Snowflake specifies INT128 for bitwise shifts
 146        if expr_type in (exp.BitwiseLeftShift, exp.BitwiseRightShift):
 147            result.set("requires_int128", True)
 148
 149        return result
 150
 151    return _builder
 152
 153
 154# https://docs.snowflake.com/en/sql-reference/functions/div0
 155def _build_if_from_div0(args: list) -> exp.If:
 156    lhs = exp._wrap(seq_get(args, 0), exp.Binary)
 157    rhs = exp._wrap(seq_get(args, 1), exp.Binary)
 158
 159    cond = exp.EQ(this=rhs, expression=exp.Literal.number(0)).and_(
 160        exp.Is(this=lhs, expression=exp.null()).not_()
 161    )
 162    true = exp.Literal.number(0)
 163    false = exp.Div(this=lhs, expression=rhs)
 164    return exp.If(this=cond, true=true, false=false)
 165
 166
 167# https://docs.snowflake.com/en/sql-reference/functions/div0null
 168def _build_if_from_div0null(args: list) -> exp.If:
 169    lhs = exp._wrap(seq_get(args, 0), exp.Binary)
 170    rhs = exp._wrap(seq_get(args, 1), exp.Binary)
 171
 172    # Returns 0 when divisor is 0 OR NULL
 173    cond = exp.EQ(this=rhs, expression=exp.Literal.number(0)).or_(
 174        exp.Is(this=rhs, expression=exp.null())
 175    )
 176    true = exp.Literal.number(0)
 177    false = exp.Div(this=lhs, expression=rhs)
 178    return exp.If(this=cond, true=true, false=false)
 179
 180
 181# https://docs.snowflake.com/en/sql-reference/functions/zeroifnull
 182def _build_if_from_zeroifnull(args: list) -> exp.If:
 183    cond = exp.Is(this=seq_get(args, 0), expression=exp.Null())
 184    return exp.If(this=cond, true=exp.Literal.number(0), false=seq_get(args, 0))
 185
 186
 187def _build_search(args: list) -> exp.Search:
 188    kwargs = {
 189        "this": seq_get(args, 0),
 190        "expression": seq_get(args, 1),
 191        **{arg.name.lower(): arg for arg in args[2:] if isinstance(arg, exp.Kwarg)},
 192    }
 193    return exp.Search(**kwargs)
 194
 195
 196# https://docs.snowflake.com/en/sql-reference/functions/zeroifnull
 197def _build_if_from_nullifzero(args: list) -> exp.If:
 198    cond = exp.EQ(this=seq_get(args, 0), expression=exp.Literal.number(0))
 199    return exp.If(this=cond, true=exp.Null(), false=seq_get(args, 0))
 200
 201
 202def _build_regexp_replace(args: list) -> exp.RegexpReplace:
 203    regexp_replace = exp.RegexpReplace.from_arg_list(args)
 204
 205    if not regexp_replace.args.get("replacement"):
 206        regexp_replace.set("replacement", exp.Literal.string(""))
 207
 208    return regexp_replace
 209
 210
 211def _build_regexp_like(args: list) -> exp.RegexpLike:
 212    return exp.RegexpLike(
 213        this=seq_get(args, 0),
 214        expression=seq_get(args, 1),
 215        flag=seq_get(args, 2),
 216        full_match=True,
 217    )
 218
 219
 220def _date_trunc_to_time(args: list) -> exp.DateTrunc | exp.TimestampTrunc:
 221    trunc = date_trunc_to_time(args)
 222    trunc.set("unit", map_date_part(trunc.args["unit"]))
 223    trunc.set("input_type_preserved", True)
 224    return trunc
 225
 226
 227def _build_trunc(args: list, dialect: Dialect) -> exp.DateTrunc | exp.Trunc | exp.Anonymous:
 228    trunc = build_trunc(args, dialect, date_trunc_requires_part=False, fractions_supported=True)
 229    if isinstance(trunc, exp.DateTrunc):
 230        trunc.set("input_type_preserved", True)
 231    return trunc
 232
 233
 234def _build_regexp_extract(expr_type: type[E]) -> t.Callable[[list, Dialect], E]:
 235    def _builder(args: list, dialect: Dialect) -> E:
 236        return expr_type(
 237            this=seq_get(args, 0),
 238            expression=seq_get(args, 1),
 239            position=seq_get(args, 2),
 240            occurrence=seq_get(args, 3),
 241            parameters=seq_get(args, 4),
 242            group=seq_get(args, 5) or exp.Literal.number(0),
 243            **(
 244                {
 245                    "null_if_pos_overflow": dialect.REGEXP_EXTRACT_POSITION_OVERFLOW_RETURNS_NULL,
 246                    "null_if_no_match": dialect.REGEXP_EXTRACT_NO_MATCH_RETURNS_NULL,
 247                    "empty_if_group_missing": dialect.REGEXP_EXTRACT_MISSING_GROUP_RETURNS_EMPTY,
 248                }
 249                if expr_type is exp.RegexpExtract
 250                else {}
 251            ),
 252        )
 253
 254    return _builder
 255
 256
 257def _build_timestamp_from_parts(args: list) -> exp.Func:
 258    """Build TimestampFromParts with support for both syntaxes:
 259    1. TIMESTAMP_FROM_PARTS(year, month, day, hour, minute, second [, nanosecond] [, time_zone])
 260    2. TIMESTAMP_FROM_PARTS(date_expr, time_expr) - Snowflake specific
 261    """
 262    if len(args) == 2:
 263        return exp.TimestampFromParts(this=seq_get(args, 0), expression=seq_get(args, 1))
 264
 265    return exp.TimestampFromParts.from_arg_list(args)
 266
 267
 268def _build_round(args: list) -> exp.Round:
 269    """
 270    Build Round expression, unwrapping Snowflake's named parameters.
 271
 272    Maps EXPR => this, SCALE => decimals, ROUNDING_MODE => truncate.
 273
 274    Note: Snowflake does not support mixing named and positional arguments.
 275    Arguments are either all named or all positional.
 276    """
 277    kwarg_map = {"EXPR": "this", "SCALE": "decimals", "ROUNDING_MODE": "truncate"}
 278    round_args = {}
 279    positional_keys = ["this", "decimals", "truncate"]
 280    positional_idx = 0
 281
 282    for arg in args:
 283        if isinstance(arg, exp.Kwarg):
 284            key = arg.this.name.upper()
 285            round_key = kwarg_map.get(key)
 286            if round_key:
 287                round_args[round_key] = arg.expression
 288        else:
 289            if positional_idx < len(positional_keys):
 290                round_args[positional_keys[positional_idx]] = arg
 291                positional_idx += 1
 292
 293    expression = exp.Round(**round_args)
 294    expression.set("casts_non_integer_decimals", True)
 295    return expression
 296
 297
 298def _build_array_sort(args: list) -> exp.ArraySort:
 299    asc = seq_get(args, 1)
 300    nulls_first = seq_get(args, 2)
 301    if nulls_first is None and (asc is None or isinstance(asc, exp.Boolean)):
 302        nulls_first = exp.Boolean(this=asc is not None and not asc.this)
 303    return exp.ArraySort(this=seq_get(args, 0), asc=asc, nulls_first=nulls_first)
 304
 305
 306def _build_generator(args: list) -> exp.Generator:
 307    """
 308    Build Generator expression, unwrapping Snowflake's named parameters.
 309
 310    Maps ROWCOUNT => rowcount, TIMELIMIT => timelimit.
 311    """
 312    kwarg_map = {"ROWCOUNT": "rowcount", "TIMELIMIT": "timelimit"}
 313    gen_args = {}
 314
 315    positional_keys = ("rowcount", "timelimit")
 316
 317    for i, arg in enumerate(args):
 318        if isinstance(arg, exp.Kwarg):
 319            key = arg.this.name.upper()
 320            gen_key = kwarg_map.get(key)
 321            if gen_key:
 322                gen_args[gen_key] = arg.expression
 323        elif i < len(positional_keys):
 324            gen_args[positional_keys[i]] = arg
 325
 326    return exp.Generator(**gen_args)
 327
 328
 329def _show_parser(*args: t.Any, **kwargs: t.Any) -> t.Callable[[SnowflakeParser], exp.Show]:
 330    def _parse(self: SnowflakeParser) -> exp.Show:
 331        return self._parse_show_snowflake(*args, **kwargs)
 332
 333    return _parse
 334
 335
 336class SnowflakeParser(parser.Parser):
 337    IDENTIFY_PIVOT_STRINGS = True
 338    TYPED_LAMBDA_ARGS = True
 339    DEFAULT_SAMPLING_METHOD = "BERNOULLI"
 340    COLON_IS_VARIANT_EXTRACT = True
 341    JSON_EXTRACT_REQUIRES_JSON_EXPRESSION = True
 342    SUPPORTS_NTH_VALUE_FROM_MODIFIER = True
 343
 344    TYPE_TOKENS = {*parser.Parser.TYPE_TOKENS, TokenType.FILE}
 345    STRUCT_TYPE_TOKENS = {*parser.Parser.STRUCT_TYPE_TOKENS, TokenType.FILE}
 346    NESTED_TYPE_TOKENS = {*parser.Parser.NESTED_TYPE_TOKENS, TokenType.FILE}
 347
 348    ID_VAR_TOKENS = {
 349        *parser.Parser.ID_VAR_TOKENS,
 350        TokenType.EXCEPT,
 351        TokenType.INTEGRATION,
 352        TokenType.LATERAL,
 353        TokenType.MATCH_CONDITION,
 354        TokenType.PACKAGE,
 355        TokenType.POLICY,
 356        TokenType.POOL,
 357        TokenType.ROLE,
 358        TokenType.ROLLBACK,
 359        TokenType.RULE,
 360        TokenType.USING,
 361        TokenType.VOLUME,
 362    }
 363
 364    FUNC_TOKENS = parser.Parser.FUNC_TOKENS | {TokenType.ROLLBACK}
 365
 366    ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS | {
 367        TokenType.INTEGRATION,
 368        TokenType.LATERAL,
 369        TokenType.PACKAGE,
 370        TokenType.POLICY,
 371        TokenType.POOL,
 372        TokenType.ROLE,
 373        TokenType.ROLLBACK,
 374        TokenType.RULE,
 375        TokenType.USING,
 376        TokenType.VOLUME,
 377    }
 378
 379    TABLE_ALIAS_TOKENS = (
 380        parser.Parser.TABLE_ALIAS_TOKENS
 381        | {
 382            TokenType.ANTI,
 383            TokenType.INTEGRATION,
 384            TokenType.PACKAGE,
 385            TokenType.POLICY,
 386            TokenType.POOL,
 387            TokenType.ROLE,
 388            TokenType.ROLLBACK,
 389            TokenType.RULE,
 390            TokenType.SEMI,
 391            TokenType.VOLUME,
 392            TokenType.WINDOW,
 393        }
 394    ) - {TokenType.MATCH_CONDITION}
 395
 396    COLON_PLACEHOLDER_TOKENS = ID_VAR_TOKENS | {TokenType.NUMBER}
 397
 398    NO_PAREN_FUNCTIONS = {
 399        **parser.Parser.NO_PAREN_FUNCTIONS,
 400        TokenType.LOCALTIME: exp.Localtime,
 401        # LOCALTIMESTAMP is a Snowflake alias of CURRENT_TIMESTAMP, like the parenthesised form in
 402        # FUNCTION_PARSERS. Only Snowflake treats it as such, so it must not map to Localtimestamp.
 403        TokenType.LOCALTIMESTAMP: exp.CurrentTimestamp,
 404        TokenType.CURRENT_TIME: exp.Localtime,
 405    }
 406
 407    RANGE_PARSERS = {
 408        **parser.Parser.RANGE_PARSERS,
 409        TokenType.RLIKE: lambda self, this: self.expression(
 410            exp.RegexpLike(this=this, expression=self._parse_bitwise(), full_match=True)
 411        ),
 412    }
 413
 414    FUNCTIONS = {
 415        **parser.Parser.FUNCTIONS,
 416        "CHARINDEX": lambda args: exp.StrPosition(
 417            this=seq_get(args, 1),
 418            substr=seq_get(args, 0),
 419            position=seq_get(args, 2),
 420            clamp_position=True,
 421        ),
 422        "ADD_MONTHS": lambda args: exp.AddMonths(
 423            this=seq_get(args, 0),
 424            expression=seq_get(args, 1),
 425            preserve_end_of_month=True,
 426        ),
 427        "APPROX_PERCENTILE": exp.ApproxQuantile.from_arg_list,
 428        "CURRENT_TIME": lambda args: exp.Localtime(this=seq_get(args, 0)),
 429        "APPROX_TOP_K": _build_approx_top_k,
 430        "ARRAY_CONSTRUCT": lambda args: exp.Array(expressions=args),
 431        "ARRAY_CONTAINS": lambda args: exp.ArrayContains(
 432            this=seq_get(args, 1),
 433            expression=seq_get(args, 0),
 434            ensure_variant=False,
 435            check_null=True,
 436        ),
 437        "ARRAY_DISTINCT": lambda args: exp.ArrayDistinct(
 438            this=seq_get(args, 0),
 439            check_null=True,
 440        ),
 441        "ARRAY_GENERATE_RANGE": lambda args: exp.GenerateSeries(
 442            # Snowflake has exclusive end semantics
 443            start=seq_get(args, 0),
 444            end=seq_get(args, 1),
 445            step=seq_get(args, 2),
 446            is_end_exclusive=True,
 447        ),
 448        "ARRAY_EXCEPT": lambda args: exp.ArrayExcept(
 449            this=seq_get(args, 0),
 450            expression=seq_get(args, 1),
 451            is_multiset=True,
 452        ),
 453        "ARRAY_INTERSECTION": lambda args: exp.ArrayIntersect(
 454            expressions=args,
 455            is_multiset=True,
 456        ),
 457        "ARRAY_POSITION": lambda args: exp.ArrayPosition(
 458            this=seq_get(args, 1),
 459            expression=seq_get(args, 0),
 460            zero_based=True,
 461        ),
 462        "ARRAY_SLICE": lambda args: exp.ArraySlice(
 463            this=seq_get(args, 0),
 464            start=seq_get(args, 1),
 465            end=seq_get(args, 2),
 466            zero_based=True,
 467        ),
 468        "ARRAY_SORT": _build_array_sort,
 469        "ARRAY_FLATTEN": exp.Flatten.from_arg_list,
 470        "ARRAY_TO_STRING": lambda args: exp.ArrayToString(
 471            this=seq_get(args, 0),
 472            expression=seq_get(args, 1),
 473            null_is_empty=True,
 474            null_delim_is_null=True,
 475        ),
 476        "ARRAYS_OVERLAP": lambda args: exp.ArrayOverlaps(
 477            this=seq_get(args, 0), expression=seq_get(args, 1), null_safe=True
 478        ),
 479        "BITAND": _build_bitwise(exp.BitwiseAnd, "BITAND"),
 480        "BIT_AND": _build_bitwise(exp.BitwiseAnd, "BITAND"),
 481        "BITNOT": lambda args: exp.BitwiseNot(this=seq_get(args, 0)),
 482        "BIT_NOT": lambda args: exp.BitwiseNot(this=seq_get(args, 0)),
 483        "BITXOR": _build_bitwise(exp.BitwiseXor, "BITXOR"),
 484        "BIT_XOR": _build_bitwise(exp.BitwiseXor, "BITXOR"),
 485        "BITOR": _build_bitwise(exp.BitwiseOr, "BITOR"),
 486        "BIT_OR": _build_bitwise(exp.BitwiseOr, "BITOR"),
 487        "BITSHIFTLEFT": _build_bitwise(exp.BitwiseLeftShift, "BITSHIFTLEFT"),
 488        "BIT_SHIFTLEFT": _build_bitwise(exp.BitwiseLeftShift, "BIT_SHIFTLEFT"),
 489        "BITSHIFTRIGHT": _build_bitwise(exp.BitwiseRightShift, "BITSHIFTRIGHT"),
 490        "BIT_SHIFTRIGHT": _build_bitwise(exp.BitwiseRightShift, "BIT_SHIFTRIGHT"),
 491        "BITANDAGG": exp.BitwiseAndAgg.from_arg_list,
 492        "BITAND_AGG": exp.BitwiseAndAgg.from_arg_list,
 493        "BIT_AND_AGG": exp.BitwiseAndAgg.from_arg_list,
 494        "BIT_ANDAGG": exp.BitwiseAndAgg.from_arg_list,
 495        "BITORAGG": exp.BitwiseOrAgg.from_arg_list,
 496        "BITOR_AGG": exp.BitwiseOrAgg.from_arg_list,
 497        "BIT_OR_AGG": exp.BitwiseOrAgg.from_arg_list,
 498        "BIT_ORAGG": exp.BitwiseOrAgg.from_arg_list,
 499        "BITXORAGG": exp.BitwiseXorAgg.from_arg_list,
 500        "BITXOR_AGG": exp.BitwiseXorAgg.from_arg_list,
 501        "BIT_XOR_AGG": exp.BitwiseXorAgg.from_arg_list,
 502        "BIT_XORAGG": exp.BitwiseXorAgg.from_arg_list,
 503        "BITMAP_OR_AGG": exp.BitmapOrAgg.from_arg_list,
 504        "BOOLAND": lambda args: exp.Booland(
 505            this=seq_get(args, 0), expression=seq_get(args, 1), round_input=True
 506        ),
 507        "BOOLOR": lambda args: exp.Boolor(
 508            this=seq_get(args, 0), expression=seq_get(args, 1), round_input=True
 509        ),
 510        "BOOLNOT": lambda args: exp.Boolnot(this=seq_get(args, 0), round_input=True),
 511        "BOOLXOR": lambda args: exp.Xor(
 512            this=seq_get(args, 0), expression=seq_get(args, 1), round_input=True
 513        ),
 514        "CORR": lambda args: exp.Corr(
 515            this=seq_get(args, 0),
 516            expression=seq_get(args, 1),
 517            null_on_zero_variance=True,
 518        ),
 519        "COUNT_IF": lambda args: exp.CountIf(this=seq_get(args, 0), zero_on_all_null=True),
 520        "DATE": _build_datetime("DATE", exp.DType.DATE),
 521        "DATEFROMPARTS": _build_date_from_parts,
 522        "DATE_FROM_PARTS": _build_date_from_parts,
 523        "DATE_TRUNC": _date_trunc_to_time,
 524        "DATEADD": lambda args: exp.DateAdd(
 525            this=seq_get(args, 2),
 526            expression=seq_get(args, 1),
 527            unit=map_date_part(seq_get(args, 0)),
 528        ),
 529        "DATEDIFF": lambda args: exp.DateDiff(
 530            this=seq_get(args, 2),
 531            expression=seq_get(args, 1),
 532            unit=map_date_part(seq_get(args, 0)),
 533            date_part_boundary=True,
 534        ),
 535        "DAYNAME": lambda args: exp.Dayname(this=seq_get(args, 0), abbreviated=True),
 536        "DAYOFWEEKISO": exp.DayOfWeekIso.from_arg_list,
 537        "DIV0": _build_if_from_div0,
 538        "DIV0NULL": _build_if_from_div0null,
 539        "EDITDISTANCE": lambda args: exp.Levenshtein(
 540            this=seq_get(args, 0), expression=seq_get(args, 1), max_dist=seq_get(args, 2)
 541        ),
 542        "FLATTEN": exp.Explode.from_arg_list,
 543        "GENERATOR": _build_generator,
 544        "GET": exp.GetExtract.from_arg_list,
 545        "GETDATE": exp.CurrentTimestamp.from_arg_list,
 546        "GET_PATH": lambda args, dialect: exp.JSONExtract(
 547            this=seq_get(args, 0),
 548            expression=dialect.to_json_path(seq_get(args, 1)),
 549            requires_json=True,
 550        ),
 551        "GREATEST_IGNORE_NULLS": lambda args: exp.Greatest(
 552            this=seq_get(args, 0), expressions=args[1:], ignore_nulls=True
 553        ),
 554        "LEAST_IGNORE_NULLS": lambda args: exp.Least(
 555            this=seq_get(args, 0), expressions=args[1:], ignore_nulls=True
 556        ),
 557        "LEFT": lambda args: exp.Left(
 558            this=seq_get(args, 0), expression=seq_get(args, 1), negative_length_returns_empty=True
 559        ),
 560        "HEX_DECODE_BINARY": exp.Unhex.from_arg_list,
 561        "HEX_ENCODE": exp.Hex.from_arg_list,
 562        "IFF": exp.If.from_arg_list,
 563        "JAROWINKLER_SIMILARITY": lambda args: exp.JarowinklerSimilarity(
 564            this=seq_get(args, 0),
 565            expression=seq_get(args, 1),
 566            case_insensitive=True,
 567            integer_scale=True,
 568        ),
 569        "MD5_HEX": exp.MD5.from_arg_list,
 570        "MD5_BINARY": exp.MD5Digest.from_arg_list,
 571        "MD5_NUMBER_LOWER64": exp.MD5NumberLower64.from_arg_list,
 572        "MD5_NUMBER_UPPER64": exp.MD5NumberUpper64.from_arg_list,
 573        "MONTHNAME": lambda args: exp.Monthname(this=seq_get(args, 0), abbreviated=True),
 574        "LAST_DAY": lambda args: exp.LastDay(
 575            this=seq_get(args, 0), unit=map_date_part(seq_get(args, 1))
 576        ),
 577        "LEN": lambda args: exp.Length(this=seq_get(args, 0), binary=True),
 578        "LENGTH": lambda args: exp.Length(this=seq_get(args, 0), binary=True),
 579        "LOCALTIMESTAMP": exp.CurrentTimestamp.from_arg_list,
 580        "NULLIFZERO": _build_if_from_nullifzero,
 581        "OBJECT_CONSTRUCT": lambda args: build_object_construct(args),
 582        "OBJECT_KEYS": exp.JSONKeys.from_arg_list,
 583        "OCTET_LENGTH": exp.ByteLength.from_arg_list,
 584        "PARSE_URL": lambda args: exp.ParseUrl(this=seq_get(args, 0), permissive=seq_get(args, 1)),
 585        "REGEXP_EXTRACT_ALL": _build_regexp_extract(exp.RegexpExtractAll),
 586        "REGEXP_LIKE": _build_regexp_like,
 587        "REGEXP_REPLACE": _build_regexp_replace,
 588        "REGEXP_SUBSTR": _build_regexp_extract(exp.RegexpExtract),
 589        "REGEXP_SUBSTR_ALL": _build_regexp_extract(exp.RegexpExtractAll),
 590        "RANDOM": lambda args: exp.Rand(
 591            this=seq_get(args, 0),
 592            lower=exp.Literal.number(-9223372036854775808.0),  # -2^63 as float to avoid overflow
 593            upper=exp.Literal.number(9223372036854775807.0),  # 2^63-1 as float
 594        ),
 595        "REPLACE": build_replace_with_optional_replacement,
 596        "RIGHT": lambda args: exp.Right(
 597            this=seq_get(args, 0), expression=seq_get(args, 1), negative_length_returns_empty=True
 598        ),
 599        "RLIKE": _build_regexp_like,
 600        "ROUND": _build_round,
 601        "SHA1_BINARY": exp.SHA1Digest.from_arg_list,
 602        "SHA1_HEX": exp.SHA.from_arg_list,
 603        "SHA2_BINARY": exp.SHA2Digest.from_arg_list,
 604        "SHA2_HEX": exp.SHA2.from_arg_list,
 605        "SPLIT": lambda args: exp.Split(
 606            this=seq_get(args, 0),
 607            expression=seq_get(args, 1),
 608            null_returns_null=True,
 609            empty_delimiter_returns_whole=True,
 610        ),
 611        "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)),
 612        "STDDEV_SAMP": exp.Stddev.from_arg_list,
 613        "SYSDATE": lambda args: exp.CurrentTimestamp(this=seq_get(args, 0), sysdate=True),
 614        "TABLE": lambda args: exp.TableFromRows(this=seq_get(args, 0)),
 615        "TIMEADD": lambda args: exp.TimeAdd(
 616            this=seq_get(args, 2),
 617            expression=seq_get(args, 1),
 618            unit=map_date_part(seq_get(args, 0)),
 619        ),
 620        "TIMEDIFF": lambda args: exp.DateDiff(
 621            this=seq_get(args, 2),
 622            expression=seq_get(args, 1),
 623            unit=map_date_part(seq_get(args, 0)),
 624            date_part_boundary=True,
 625        ),
 626        "TIME_FROM_PARTS": lambda args: exp.TimeFromParts(
 627            hour=seq_get(args, 0),
 628            min=seq_get(args, 1),
 629            sec=seq_get(args, 2),
 630            nano=seq_get(args, 3),
 631            overflow=True,
 632        ),
 633        "TIMESTAMPADD": lambda args: exp.DateAdd(
 634            this=seq_get(args, 2),
 635            expression=seq_get(args, 1),
 636            unit=map_date_part(seq_get(args, 0)),
 637        ),
 638        "TIMESTAMPDIFF": lambda args: exp.DateDiff(
 639            this=seq_get(args, 2),
 640            expression=seq_get(args, 1),
 641            unit=map_date_part(seq_get(args, 0)),
 642            date_part_boundary=True,
 643        ),
 644        "TIMESTAMPFROMPARTS": _build_timestamp_from_parts,
 645        "TIMESTAMP_FROM_PARTS": _build_timestamp_from_parts,
 646        "TIMESTAMPNTZFROMPARTS": _build_timestamp_from_parts,
 647        "TIMESTAMP_NTZ_FROM_PARTS": _build_timestamp_from_parts,
 648        "TRUNC": _build_trunc,
 649        "TRUNCATE": _build_trunc,
 650        "TRY_DECRYPT": lambda args: exp.Decrypt(
 651            this=seq_get(args, 0),
 652            passphrase=seq_get(args, 1),
 653            aad=seq_get(args, 2),
 654            encryption_method=seq_get(args, 3),
 655            safe=True,
 656        ),
 657        "TRY_DECRYPT_RAW": lambda args: exp.DecryptRaw(
 658            this=seq_get(args, 0),
 659            key=seq_get(args, 1),
 660            iv=seq_get(args, 2),
 661            aad=seq_get(args, 3),
 662            encryption_method=seq_get(args, 4),
 663            aead=seq_get(args, 5),
 664            safe=True,
 665        ),
 666        "TRY_PARSE_JSON": lambda args: exp.ParseJSON(this=seq_get(args, 0), safe=True),
 667        "TRY_TO_BINARY": lambda args: exp.ToBinary(
 668            this=seq_get(args, 0), format=seq_get(args, 1), safe=True
 669        ),
 670        "TRY_TO_BOOLEAN": lambda args: exp.ToBoolean(this=seq_get(args, 0), safe=True),
 671        "TRY_TO_DATE": _build_datetime("TRY_TO_DATE", exp.DType.DATE, safe=True),
 672        **dict.fromkeys(
 673            ("TRY_TO_DECIMAL", "TRY_TO_NUMBER", "TRY_TO_NUMERIC"),
 674            lambda args: _build_to_number(args, safe=True),
 675        ),
 676        "TRY_TO_DOUBLE": lambda args: exp.ToDouble(
 677            this=seq_get(args, 0), format=seq_get(args, 1), safe=True
 678        ),
 679        "TRY_TO_FILE": lambda args: exp.ToFile(
 680            this=seq_get(args, 0), path=seq_get(args, 1), safe=True
 681        ),
 682        "TRY_TO_TIME": _build_datetime("TRY_TO_TIME", exp.DType.TIME, safe=True),
 683        "TRY_TO_TIMESTAMP": _build_datetime("TRY_TO_TIMESTAMP", exp.DType.TIMESTAMP, safe=True),
 684        "TRY_TO_TIMESTAMP_LTZ": _build_datetime(
 685            "TRY_TO_TIMESTAMP_LTZ", exp.DType.TIMESTAMPLTZ, safe=True
 686        ),
 687        "TRY_TO_TIMESTAMP_NTZ": _build_datetime(
 688            "TRY_TO_TIMESTAMP_NTZ", exp.DType.TIMESTAMPNTZ, safe=True
 689        ),
 690        "TRY_TO_TIMESTAMP_TZ": _build_datetime(
 691            "TRY_TO_TIMESTAMP_TZ", exp.DType.TIMESTAMPTZ, safe=True
 692        ),
 693        "TO_CHAR": build_timetostr_or_tochar,
 694        "TO_DATE": _build_datetime("TO_DATE", exp.DType.DATE),
 695        **dict.fromkeys(
 696            ("TO_DECIMAL", "TO_NUMBER", "TO_NUMERIC"),
 697            lambda args: _build_to_number(args),
 698        ),
 699        "TO_TIME": _build_datetime("TO_TIME", exp.DType.TIME),
 700        "TO_TIMESTAMP": _build_datetime("TO_TIMESTAMP", exp.DType.TIMESTAMP),
 701        "TO_TIMESTAMP_LTZ": _build_datetime("TO_TIMESTAMP_LTZ", exp.DType.TIMESTAMPLTZ),
 702        "TO_TIMESTAMP_NTZ": _build_datetime("TO_TIMESTAMP_NTZ", exp.DType.TIMESTAMPNTZ),
 703        "TO_TIMESTAMP_TZ": _build_datetime("TO_TIMESTAMP_TZ", exp.DType.TIMESTAMPTZ),
 704        "TO_GEOGRAPHY": lambda args: (
 705            exp.cast(args[0], exp.DType.GEOGRAPHY)
 706            if len(args) == 1
 707            else exp.Anonymous(this="TO_GEOGRAPHY", expressions=args)
 708        ),
 709        "TO_GEOMETRY": lambda args: (
 710            exp.cast(args[0], exp.DType.GEOMETRY)
 711            if len(args) == 1
 712            else exp.Anonymous(this="TO_GEOMETRY", expressions=args)
 713        ),
 714        "TO_VARCHAR": build_timetostr_or_tochar,
 715        "TO_JSON": exp.JSONFormat.from_arg_list,
 716        "VECTOR_COSINE_SIMILARITY": exp.CosineDistance.from_arg_list,
 717        "VECTOR_INNER_PRODUCT": exp.DotProduct.from_arg_list,
 718        "VECTOR_L1_DISTANCE": exp.ManhattanDistance.from_arg_list,
 719        "VECTOR_L2_DISTANCE": exp.EuclideanDistance.from_arg_list,
 720        "ZEROIFNULL": _build_if_from_zeroifnull,
 721        "LIKE": build_like(exp.Like),
 722        "ILIKE": build_like(exp.ILike),
 723        "SEARCH": _build_search,
 724        "SKEW": exp.Skewness.from_arg_list,
 725        "SPLIT_PART": lambda args: exp.SplitPart(
 726            this=seq_get(args, 0),
 727            delimiter=seq_get(args, 1),
 728            part_index=seq_get(args, 2),
 729            part_index_zero_as_one=True,
 730            empty_delimiter_returns_whole=True,
 731        ),
 732        "STRTOK": lambda args: exp.Strtok(
 733            this=seq_get(args, 0),
 734            delimiter=seq_get(args, 1) or exp.Literal.string(" "),
 735            part_index=seq_get(args, 2) or exp.Literal.number("1"),
 736        ),
 737        "STRTOK_TO_ARRAY": lambda args: exp.StrtokToArray(
 738            this=seq_get(args, 0),
 739            expression=seq_get(args, 1) or exp.Literal.string(" "),
 740        ),
 741        "SYSTIMESTAMP": exp.CurrentTimestamp.from_arg_list,
 742        "IDENTIFIER": exp.DynamicIdentifier.from_arg_list,
 743        "UNICODE": lambda args: exp.Unicode(this=seq_get(args, 0), empty_is_zero=True),
 744        "WEEKISO": exp.WeekOfYear.from_arg_list,
 745        "WEEKOFYEAR": exp.Week.from_arg_list,
 746    }
 747    FUNCTIONS = {k: v for k, v in FUNCTIONS.items() if k != "PREDICT"}
 748
 749    FUNCTION_PARSERS = {
 750        **parser.Parser.FUNCTION_PARSERS,
 751        "DATE_PART": lambda self: self._parse_date_part(),
 752        "DIRECTORY": lambda self: self._parse_directory(),
 753        "OBJECT_CONSTRUCT_KEEP_NULL": lambda self: self._parse_object_construct_keep_null(),
 754        "LISTAGG": lambda self: self._parse_listagg(),
 755        "SEMANTIC_VIEW": lambda self: self._parse_semantic_view(),
 756        "SUBSTR": lambda self: self._parse_substring(),
 757    }
 758    FUNCTION_PARSERS = {k: v for k, v in FUNCTION_PARSERS.items() if k != "TRIM"}
 759
 760    TIMESTAMPS = parser.Parser.TIMESTAMPS - {TokenType.TIME}
 761
 762    ALTER_PARSERS = {
 763        **parser.Parser.ALTER_PARSERS,
 764        "MODIFY": lambda self: self._parse_alter_table_alter(),
 765        "SESSION": lambda self: self._parse_alter_session(),
 766        "UNSET": lambda self: self.expression(
 767            exp.Set(
 768                tag=self._match_text_seq("TAG"),
 769                expressions=self._parse_csv(self._parse_id_var),
 770                unset=True,
 771            )
 772        ),
 773    }
 774
 775    STATEMENT_PARSERS = {
 776        **{
 777            k: v
 778            for k, v in parser.Parser.STATEMENT_PARSERS.items()
 779            if k not in (TokenType.PIVOT, TokenType.UNPIVOT)
 780        },
 781        TokenType.GET: lambda self: self._parse_get(),
 782        TokenType.LIST: lambda self: self._parse_list_stage(),
 783        TokenType.PUT: lambda self: self._parse_put(),
 784        TokenType.SHOW: lambda self: self._parse_show(),
 785        TokenType.UNDROP: lambda self: self._parse_undrop(),
 786    }
 787
 788    PROPERTY_PARSERS = {
 789        **parser.Parser.PROPERTY_PARSERS,
 790        "CREDENTIALS": lambda self: self._parse_credentials_property(),
 791        "FILE_FORMAT": lambda self: self._parse_file_format_property(),
 792        "IGNORE": lambda self: self._parse_ignore_property(),
 793        "INTERACTIVE": lambda self: self.expression(exp.InteractiveProperty()),
 794        "LOCATION": lambda self: self._parse_location_property(),
 795        "ROW": lambda self: (
 796            self._parse_row_access_policy()
 797            if self._match_text_seq("ACCESS", "POLICY")
 798            else self._parse_row()
 799        ),
 800        "SCOPED": lambda self: (
 801            self._match_texts(("TEMP", "TEMPORARY"))
 802            and self.expression(exp.TemporaryProperty(scoped=True))
 803        ),
 804        "TAG": lambda self: self._parse_tag(),
 805        "USING": lambda self: (
 806            self._match_text_seq("TEMPLATE")
 807            and self.expression(exp.UsingTemplateProperty(this=self._parse_statement()))
 808        ),
 809    }
 810
 811    DESCRIBE_QUALIFIER_PARSERS: t.ClassVar[dict[str, t.Callable]] = {
 812        "API": lambda self: self.expression(exp.ApiProperty()),
 813        "APPLICATION": lambda self: self.expression(exp.ApplicationProperty()),
 814        "CATALOG": lambda self: self.expression(exp.CatalogProperty()),
 815        "COMPUTE": lambda self: self.expression(exp.ComputeProperty()),
 816        "DATABASE": lambda self: (
 817            self.expression(exp.DatabaseProperty())
 818            if self._curr and self._curr.text.upper() == "ROLE"
 819            else None
 820        ),
 821        "DYNAMIC": lambda self: self.expression(exp.DynamicProperty()),
 822        "EXTERNAL": lambda self: self.expression(exp.ExternalProperty()),
 823        "HYBRID": lambda self: self.expression(exp.HybridProperty()),
 824        "ICEBERG": lambda self: self.expression(exp.IcebergProperty()),
 825        "MASKING": lambda self: self.expression(exp.MaskingProperty()),
 826        "MATERIALIZED": lambda self: self.expression(exp.MaterializedProperty()),
 827        "NETWORK": lambda self: self.expression(exp.NetworkProperty()),
 828        "ROW": lambda self: (
 829            self.expression(exp.RowAccessProperty()) if self._match_text_seq("ACCESS") else None
 830        ),
 831        "SECURITY": lambda self: (
 832            self.expression(exp.SecurityIntegrationProperty())
 833            if self._curr and self._curr.text.upper() == "INTEGRATION"
 834            else None
 835        ),
 836    }
 837
 838    TYPE_CONVERTERS = {
 839        # https://docs.snowflake.com/en/sql-reference/data-types-numeric#number
 840        exp.DType.DECIMAL: build_default_decimal_type(precision=38, scale=0),
 841    }
 842
 843    SHOW_PARSERS = {
 844        "DATABASES": _show_parser("DATABASES"),
 845        "SCHEMAS": _show_parser("SCHEMAS"),
 846        "OBJECTS": _show_parser("OBJECTS"),
 847        "TABLES": _show_parser("TABLES"),
 848        "VIEWS": _show_parser("VIEWS"),
 849        "PRIMARY KEYS": _show_parser("PRIMARY KEYS"),
 850        "IMPORTED KEYS": _show_parser("IMPORTED KEYS"),
 851        "UNIQUE KEYS": _show_parser("UNIQUE KEYS"),
 852        "SEQUENCES": _show_parser("SEQUENCES"),
 853        "STAGES": _show_parser("STAGES"),
 854        "COLUMNS": _show_parser("COLUMNS"),
 855        "USERS": _show_parser("USERS"),
 856        "FILE FORMATS": _show_parser("FILE FORMATS"),
 857        "FUNCTIONS": _show_parser("FUNCTIONS"),
 858        "PROCEDURES": _show_parser("PROCEDURES"),
 859        "WAREHOUSES": _show_parser("WAREHOUSES"),
 860        "ICEBERG TABLES": _show_parser("TABLES", iceberg=True),
 861        "TERSE ICEBERG TABLES": _show_parser("TABLES", terse=True, iceberg=True),
 862        "TERSE DATABASES": _show_parser("DATABASES", terse=True),
 863        "TERSE SCHEMAS": _show_parser("SCHEMAS", terse=True),
 864        "TERSE OBJECTS": _show_parser("OBJECTS", terse=True),
 865        "TERSE TABLES": _show_parser("TABLES", terse=True),
 866        "TERSE VIEWS": _show_parser("VIEWS", terse=True),
 867        "TERSE SEQUENCES": _show_parser("SEQUENCES", terse=True),
 868        "TERSE USERS": _show_parser("USERS", terse=True),
 869        # TERSE has no semantic effect for KEYS, so we do not set the terse AST arg
 870        "TERSE PRIMARY KEYS": _show_parser("PRIMARY KEYS"),
 871        "TERSE IMPORTED KEYS": _show_parser("IMPORTED KEYS"),
 872        "TERSE UNIQUE KEYS": _show_parser("UNIQUE KEYS"),
 873    }
 874
 875    SHOW_TRIE = new_trie(key.split(" ") for key in SHOW_PARSERS)
 876
 877    SCHEMA_UNNAMED_CONSTRAINTS = parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS - {"EXCLUDE"}
 878
 879    CONSTRAINT_PARSERS = {
 880        **parser.Parser.CONSTRAINT_PARSERS,
 881        "WITH": lambda self: self._parse_with_constraint(),
 882        "MASKING": lambda self: self._parse_with_constraint(),
 883        "PROJECTION": lambda self: self._parse_with_constraint(),
 884        "TAG": lambda self: self._parse_with_constraint(),
 885    }
 886
 887    STAGED_FILE_SINGLE_TOKENS: t.ClassVar = {
 888        TokenType.DOT,
 889        TokenType.MOD,
 890        TokenType.SLASH,
 891    }
 892
 893    FLATTEN_COLUMNS: t.ClassVar = ["SEQ", "KEY", "PATH", "INDEX", "VALUE", "THIS"]
 894
 895    SCHEMA_KINDS: t.ClassVar = {
 896        "OBJECTS",
 897        "TABLES",
 898        "VIEWS",
 899        "SEQUENCES",
 900        "UNIQUE KEYS",
 901        "IMPORTED KEYS",
 902    }
 903
 904    NON_TABLE_CREATABLES: t.ClassVar = {"STORAGE INTEGRATION", "TAG", "WAREHOUSE", "STREAMLIT"}
 905
 906    UNDROP_OBJECTS: t.ClassVar[parser.OPTIONS_TYPE] = {
 907        **dict.fromkeys(
 908            (
 909                "ACCOUNT",
 910                "DATABASE",
 911                "NOTEBOOK",
 912                "SCHEMA",
 913                "SNAPSHOT",
 914                "STREAMLIT",
 915                "TABLE",
 916                "TAG",
 917                "TYPE",
 918            ),
 919            tuple(),
 920        ),
 921        "DYNAMIC": ("TABLE",),
 922        "EXTERNAL": ("VOLUME",),
 923        "ICEBERG": ("TABLE",),
 924    }
 925
 926    CREATABLES = {
 927        *parser.Parser.CREATABLES,
 928        TokenType.INTEGRATION,
 929        TokenType.PACKAGE,
 930        TokenType.POLICY,
 931        TokenType.POOL,
 932        TokenType.ROLE,
 933        TokenType.RULE,
 934        TokenType.VOLUME,
 935    }
 936
 937    LAMBDAS = {
 938        **parser.Parser.LAMBDAS,
 939        TokenType.ARROW: lambda self, expressions: self.expression(
 940            exp.Lambda(
 941                this=self._replace_lambda(
 942                    self._parse_assignment(),
 943                    expressions,
 944                ),
 945                expressions=[e.this if isinstance(e, exp.Cast) else e for e in expressions],
 946            )
 947        ),
 948    }
 949
 950    COLUMN_OPERATORS = {
 951        **parser.Parser.COLUMN_OPERATORS,
 952        TokenType.EXCLAMATION: lambda self, this, attr: self.expression(
 953            exp.ModelAttribute(this=this, expression=attr)
 954        ),
 955    }
 956
 957    def _parse_directory(self) -> exp.DirectoryStage:
 958        table = self._parse_table_parts()
 959        this = table.this if isinstance(table, exp.Table) else table
 960        return self.expression(exp.DirectoryStage(this=this))
 961
 962    def _parse_describe(self) -> exp.Describe:
 963        index = self._index
 964
 965        if self._match_texts(self.DESCRIBE_QUALIFIER_PARSERS):
 966            qualifier = self.DESCRIBE_QUALIFIER_PARSERS[self._prev.text.upper()](self)
 967
 968            if qualifier:
 969                kind = self._match_set(self.CREATABLES) and self._prev.text.upper()
 970
 971                if kind:
 972                    this = self._parse_table(schema=True)
 973                    properties = self.expression(exp.Properties(expressions=[qualifier]))
 974                    post_props = self._parse_properties()
 975                    expressions = post_props.expressions if post_props else None
 976                    return self.expression(
 977                        exp.Describe(
 978                            this=this,
 979                            kind=kind,
 980                            properties=properties,
 981                            expressions=expressions,
 982                        )
 983                    )
 984
 985        self._retreat(index)
 986        return super()._parse_describe()
 987
 988    def _parse_use(self) -> exp.Use:
 989        if self._match_text_seq("SECONDARY", "ROLES"):
 990            this = self._match_texts(("ALL", "NONE")) and exp.var(self._prev.text.upper())
 991            roles = None if this else self._parse_csv(lambda: self._parse_table(schema=False))
 992            return self.expression(exp.Use(kind="SECONDARY ROLES", this=this, expressions=roles))
 993
 994        return super()._parse_use()
 995
 996    def _negate_range(self, this: exp.Expr | None = None) -> exp.Expr | None:
 997        if not this:
 998            return this
 999
1000        query = this.args.get("query")
1001        if isinstance(this, exp.In) and isinstance(query, exp.Query):
1002            # Snowflake treats `value NOT IN (subquery)` as `VALUE <> ALL (subquery)`, so
1003            # we do this conversion here to avoid parsing it into `NOT value IN (subquery)`
1004            # which can produce different results (most likely a SnowFlake bug).
1005            #
1006            # https://docs.snowflake.com/en/sql-reference/functions/in
1007            # Context: https://github.com/tobymao/sqlglot/issues/3890
1008            return self.expression(exp.NEQ(this=this.this, expression=exp.All(this=query.unnest())))
1009
1010        return self.expression(exp.Not(this=this))
1011
1012    def _parse_copy_property(self) -> exp.Property | None:
1013        if self._match_text_seq("TAGS"):
1014            return self.expression(exp.CopyTagsProperty())
1015        return super()._parse_copy_property()
1016
1017    def _parse_ignore_property(self) -> exp.Property | None:
1018        if not self._match_text_seq("GRANTS"):
1019            self._retreat(self._index - 1)
1020            return None
1021
1022        return self.expression(exp.IgnoreGrantsProperty())
1023
1024    def _parse_tag(self) -> exp.Tags:
1025        return self.expression(exp.Tags(expressions=self._parse_wrapped_csv(self._parse_property)))
1026
1027    def _parse_property_before(self) -> exp.Expr | list[exp.Expr] | None:
1028        prop = super()._parse_property_before()
1029        if prop:
1030            return prop
1031
1032        if not self._next or self._next.token_type != TokenType.EQ:
1033            return None
1034
1035        return self._parse_sequence_properties() or self._parse_key_value_property(
1036            self._parse_primary_or_var
1037        )
1038
1039    def _parse_with_constraint(self) -> exp.Expr | None:
1040        if self._prev.token_type != TokenType.WITH:
1041            self._retreat(self._index - 1)
1042
1043        if self._match_text_seq("MASKING", "POLICY"):
1044            policy = self._parse_column()
1045            return self.expression(
1046                exp.MaskingPolicyColumnConstraint(
1047                    this=policy.to_dot() if isinstance(policy, exp.Column) else policy,
1048                    expressions=self._match(TokenType.USING)
1049                    and self._parse_wrapped_csv(self._parse_id_var),
1050                )
1051            )
1052        if self._match_text_seq("PROJECTION", "POLICY"):
1053            policy = self._parse_column()
1054            return self.expression(
1055                exp.ProjectionPolicyColumnConstraint(
1056                    this=policy.to_dot() if isinstance(policy, exp.Column) else policy
1057                )
1058            )
1059        if self._match(TokenType.TAG):
1060            return self._parse_tag()
1061
1062        return None
1063
1064    def _parse_with_property(self) -> exp.Expr | None | list[exp.Expr]:
1065        if self._match(TokenType.TAG):
1066            return self._parse_tag()
1067
1068        if self._match_text_seq("ROW", "ACCESS", "POLICY"):
1069            return self._parse_row_access_policy()
1070
1071        return super()._parse_with_property()
1072
1073    def _parse_row_access_policy(self) -> exp.RowAccessProperty:
1074        # GET_DDL outputs #unknown_policy when the user lacks privileges to see the policy name
1075        if self._match(TokenType.HASH):
1076            policy: exp.Expr | None = self._parse_var(any_token=True)
1077            if policy:
1078                policy = exp.Var(this=f"#{policy.name}")
1079            expressions = None
1080        else:
1081            policy = self._parse_column()
1082            if isinstance(policy, exp.Column):
1083                policy = policy.to_dot()
1084            if not self._match(TokenType.ON):
1085                self.raise_error("Expected ON after ROW ACCESS POLICY name")
1086            expressions = self._parse_wrapped_csv(self._parse_id_var)
1087
1088        return self.expression(exp.RowAccessProperty(this=policy, expressions=expressions))
1089
1090    def _parse_create(self) -> exp.Create | exp.Command:
1091        expression = super()._parse_create()
1092        if isinstance(expression, exp.Create) and expression.kind in self.NON_TABLE_CREATABLES:
1093            # Replace the Table node with the enclosed Identifier
1094            expression.this.replace(expression.this.this)
1095
1096        return expression
1097
1098    def _parse_listagg(self) -> exp.GroupConcat:
1099        expression = self._parse_string_agg()
1100        if expression.args.get("separator") is None:
1101            expression.set("separator", exp.Literal.string(""))
1102        return expression
1103
1104    def _parse_object_construct_keep_null(self) -> exp.JSONObject:
1105        index = self._index
1106        column = self._parse_column()
1107        if column and column.is_star:
1108            return self.expression(exp.JSONObject(expressions=[column]))
1109
1110        self._retreat(index)
1111        return self._parse_json_object(agg=False)
1112
1113    # https://docs.snowflake.com/en/sql-reference/functions/date_part.html
1114    # https://docs.snowflake.com/en/sql-reference/functions-date-time.html#label-supported-date-time-parts
1115    def _parse_date_part(self) -> exp.Expr | None:
1116        this = self._parse_var() or self._parse_type()
1117
1118        if not this:
1119            return None
1120
1121        # Handle both syntaxes: DATE_PART(part, expr) and DATE_PART(part FROM expr)
1122        expression = self._match_set((TokenType.FROM, TokenType.COMMA)) and self._parse_bitwise()
1123        return self.expression(
1124            exp.Extract(this=map_date_part(this, self.dialect), expression=expression)
1125        )
1126
1127    def _parse_bracket_key_value(self, is_map: bool = False) -> exp.Expr | None:
1128        if is_map:
1129            # Keys are strings in Snowflake's objects, see also:
1130            # - https://docs.snowflake.com/en/sql-reference/data-types-semistructured
1131            # - https://docs.snowflake.com/en/sql-reference/functions/object_construct
1132            return self._parse_slice(self._parse_string()) or self._parse_assignment()
1133
1134        return self._parse_slice(self._parse_alias(self._parse_assignment(), explicit=True))
1135
1136    def _parse_lateral(self) -> exp.Lateral | None:
1137        lateral = super()._parse_lateral()
1138        if not lateral:
1139            return lateral
1140
1141        if isinstance(lateral.this, exp.Explode):
1142            table_alias = lateral.args.get("alias")
1143            columns = [exp.to_identifier(col) for col in self.FLATTEN_COLUMNS]
1144            if table_alias and not table_alias.args.get("columns"):
1145                table_alias.set("columns", columns)
1146            elif not table_alias:
1147                exp.alias_(lateral, "_flattened", table=columns, copy=False)
1148
1149        return lateral
1150
1151    def _parse_table_parts(
1152        self,
1153        schema: bool = False,
1154        is_db_reference: bool = False,
1155        wildcard: bool = False,
1156        fast: bool = False,
1157    ) -> exp.Table | exp.Dot | None:
1158        # https://docs.snowflake.com/en/user-guide/querying-stage
1159        if self._match(TokenType.STRING, advance=False):
1160            table = self._parse_string()
1161        elif self._match_text_seq("@", advance=False):
1162            table = self._parse_location_path()
1163        else:
1164            table = None
1165
1166        if table:
1167            file_format = None
1168            pattern = None
1169
1170            wrapped = self._match(TokenType.L_PAREN)
1171            while self._curr and wrapped and not self._match(TokenType.R_PAREN):
1172                if self._match_text_seq("FILE_FORMAT", "=>"):
1173                    file_format = self._parse_string() or super()._parse_table_parts(
1174                        is_db_reference=is_db_reference
1175                    )
1176                elif self._match_text_seq("PATTERN", "=>"):
1177                    pattern = self._parse_string()
1178                else:
1179                    break
1180
1181                self._match(TokenType.COMMA)
1182
1183            table = self.expression(exp.Table(this=table, format=file_format, pattern=pattern))
1184        else:
1185            table = super()._parse_table_parts(
1186                schema=schema,
1187                is_db_reference=is_db_reference,
1188                fast=fast,
1189            )
1190
1191        return table
1192
1193    def _parse_function_call(
1194        self,
1195        functions: dict[str, t.Callable] | None = None,
1196        anonymous: bool = False,
1197        optional_parens: bool = True,
1198        any_token: bool = False,
1199    ) -> exp.Expr | None:
1200        this = super()._parse_function_call(
1201            functions=functions,
1202            anonymous=anonymous,
1203            optional_parens=optional_parens,
1204            any_token=any_token,
1205        )
1206
1207        # Snowflake can invoke a function whose name is dynamically resolved, e.g.
1208        # `IDENTIFIER('my_func')(1, 2)`. The trailing argument list is the call's arguments.
1209        #
1210        # https://docs.snowflake.com/en/sql-reference/identifier-literal
1211        if isinstance(this, exp.DynamicIdentifier) and self._match(
1212            TokenType.L_PAREN, advance=False
1213        ):
1214            this.set("expressions", self._parse_wrapped_csv(self._parse_lambda))
1215
1216        return this
1217
1218    def _parse_id_var(
1219        self,
1220        any_token: bool = True,
1221        tokens: Collection[TokenType] | None = None,
1222    ) -> exp.Expr | None:
1223        if self._match_text_seq("IDENTIFIER", "("):
1224            identifier = (
1225                super()._parse_id_var(any_token=any_token, tokens=tokens) or self._parse_string()
1226            )
1227            self._match_r_paren()
1228            return self.expression(exp.DynamicIdentifier(this=identifier))
1229
1230        return super()._parse_id_var(any_token=any_token, tokens=tokens)
1231
1232    def _parse_show_snowflake(
1233        self, this: str, terse: bool = False, iceberg: bool = False
1234    ) -> exp.Show:
1235        scope = None
1236        scope_kind = None
1237
1238        history = self._match_text_seq("HISTORY")
1239
1240        like = self._parse_string() if self._match(TokenType.LIKE) else None
1241
1242        if self._match(TokenType.IN):
1243            if self._match_text_seq("ACCOUNT"):
1244                scope_kind = "ACCOUNT"
1245            elif self._match_text_seq("CLASS"):
1246                scope_kind = "CLASS"
1247                scope = self._parse_table_parts()
1248            elif self._match_text_seq("APPLICATION"):
1249                scope_kind = "APPLICATION"
1250                if self._match_text_seq("PACKAGE"):
1251                    scope_kind += " PACKAGE"
1252                scope = self._parse_table_parts()
1253            elif self._match_set(self.DB_CREATABLES):
1254                scope_kind = self._prev.text.upper()
1255                if self._curr:
1256                    scope = self._parse_table_parts()
1257            elif self._curr:
1258                scope_kind = "SCHEMA" if this in self.SCHEMA_KINDS else "TABLE"
1259                scope = self._parse_table_parts()
1260
1261        return self.expression(
1262            exp.Show(
1263                terse=terse,
1264                iceberg=iceberg,
1265                this=this,
1266                history=history,
1267                like=like,
1268                scope=scope,
1269                scope_kind=scope_kind,
1270                starts_with=self._match_text_seq("STARTS", "WITH") and self._parse_string(),
1271                limit=self._parse_limit(),
1272                from_=self._parse_string() if self._match(TokenType.FROM) else None,
1273                privileges=self._match_text_seq("WITH", "PRIVILEGES")
1274                and self._parse_csv(lambda: self._parse_var(any_token=True, upper=True)),
1275            )
1276        )
1277
1278    def _parse_undrop(self) -> exp.Undrop | exp.Command:
1279        start = self._prev
1280        kind = self._parse_var_from_options(self.UNDROP_OBJECTS, raise_unmatched=False)
1281        if not kind:
1282            return self._parse_as_command(start)
1283
1284        this = self._parse_table_parts(
1285            is_db_reference=kind.name in ("ACCOUNT", "DATABASE", "SCHEMA")
1286        )
1287        rename = self._parse_table_parts() if self._match_text_seq("RENAME", "TO") else None
1288        return self.expression(exp.Undrop(this=this, kind=kind.name, rename=rename))
1289
1290    def _parse_put(self) -> exp.Put | exp.Command:
1291        if self._curr.token_type not in (TokenType.STRING, TokenType.URI_START):
1292            return self._parse_as_command(self._prev)
1293
1294        return self.expression(
1295            exp.Put(
1296                this=self._parse_string() or exp.Literal.string(self._parse_location_path().name),
1297                target=self._parse_location_path(),
1298                properties=self._parse_properties(),
1299            )
1300        )
1301
1302    def _parse_get(self) -> exp.Expr | None:
1303        start = self._prev
1304
1305        # If we detect GET( then we need to parse a function, not a statement
1306        if self._match(TokenType.L_PAREN):
1307            self._retreat(self._index - 2)
1308            return self._parse_expression()
1309
1310        target = self._parse_location_path()
1311
1312        # Parse as command if unquoted file path
1313        if self._curr.token_type == TokenType.URI_START:
1314            return self._parse_as_command(start)
1315
1316        return self.expression(
1317            exp.Get(this=self._parse_string(), target=target, properties=self._parse_properties())
1318        )
1319
1320    def _parse_list_stage(self) -> exp.ListStage:
1321        this = self._parse_location_path() if self._curr else None
1322        pattern = None
1323        if self._match_text_seq("PATTERN", "="):
1324            pattern = self._parse_string()
1325            if pattern is None:
1326                self.raise_error("Expected string after PATTERN =")
1327
1328        return self.expression(exp.ListStage(this=this, pattern=pattern))
1329
1330    def _parse_location_property(self) -> exp.LocationProperty:
1331        self._match(TokenType.EQ)
1332        return self.expression(exp.LocationProperty(this=self._parse_location_path()))
1333
1334    def _parse_file_location(self) -> exp.Expr | None:
1335        # Parse either a subquery or a staged file
1336        return (
1337            self._parse_select(table=True, parse_subquery_alias=False)
1338            if self._match(TokenType.L_PAREN, advance=False)
1339            else self._parse_table_parts()
1340        )
1341
1342    def _parse_location_path(self) -> exp.Var:
1343        start = self._curr
1344        self._advance_any(ignore_reserved=True)
1345
1346        # We avoid consuming a comma token because external tables like @foo and @bar
1347        # can be joined in a query with a comma separator, as well as closing paren
1348        # in case of subqueries
1349        while self._is_connected() and not self._match_set(
1350            (TokenType.COMMA, TokenType.L_PAREN, TokenType.R_PAREN), advance=False
1351        ):
1352            self._advance_any(ignore_reserved=True)
1353
1354        return exp.var(self._find_sql(start, self._prev))
1355
1356    def _parse_lambda_arg(self) -> exp.Expr | None:
1357        this = super()._parse_lambda_arg()
1358
1359        if not this:
1360            return this
1361
1362        typ = self._parse_types()
1363
1364        if typ:
1365            return self.expression(exp.Cast(this=this, to=typ))
1366
1367        return this
1368
1369    def _parse_foreign_key(self) -> exp.ForeignKey:
1370        # inlineFK, the REFERENCES columns are implied
1371        if self._match(TokenType.REFERENCES, advance=False):
1372            return self.expression(exp.ForeignKey())
1373
1374        # outoflineFK, explicitly names the columns
1375        return super()._parse_foreign_key()
1376
1377    def _parse_file_format_property(self) -> exp.FileFormatProperty:
1378        self._match(TokenType.EQ)
1379        if self._match(TokenType.L_PAREN, advance=False):
1380            expressions = self._parse_wrapped_options()
1381        else:
1382            expressions = [self._parse_format_name()]
1383
1384        return self.expression(exp.FileFormatProperty(expressions=expressions))
1385
1386    def _parse_credentials_property(self) -> exp.CredentialsProperty:
1387        return self.expression(exp.CredentialsProperty(expressions=self._parse_wrapped_options()))
1388
1389    def _parse_semantic_view(self) -> exp.SemanticView:
1390        kwargs: dict[str, t.Any] = {"this": self._parse_table_parts()}
1391
1392        while self._curr and not self._match(TokenType.R_PAREN, advance=False):
1393            if self._match_texts(("DIMENSIONS", "METRICS", "FACTS")):
1394                keyword = self._prev.text.lower()
1395                kwargs[keyword] = self._parse_csv(
1396                    lambda: self._parse_alias(self._parse_disjunction(), explicit=True)
1397                )
1398            elif self._match_text_seq("WHERE"):
1399                kwargs["where"] = self._parse_expression()
1400            else:
1401                self.raise_error("Expecting ) or encountered unexpected keyword")
1402                break
1403
1404        return self.expression(exp.SemanticView(**kwargs))
1405
1406    def _parse_set(self, unset: bool = False, tag: bool = False) -> exp.Set | exp.Command:
1407        set = super()._parse_set(unset=unset, tag=tag)
1408
1409        if isinstance(set, exp.Set):
1410            for expr in set.expressions:
1411                if isinstance(expr, exp.SetItem):
1412                    expr.set("kind", "VARIABLE")
1413        return set
1414
1415    def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
1416        result = super()._parse_position(haystack_first)
1417        result.set("clamp_position", True)
1418        return result
1419
1420    def _parse_substring(self) -> exp.Substring:
1421        result = super()._parse_substring()
1422        result.set("zero_start", True)
1423        return result
1424
1425    def build_cast(self, strict: bool, **kwargs) -> exp.Expr:
1426        to = kwargs.get("to")
1427        if not strict and to and to.this == exp.DataType.Type.BOOLEAN:
1428            return self.expression(exp.ToBoolean(this=kwargs.get("this"), safe=True))
1429        cast = super().build_cast(strict, **kwargs)
1430        if isinstance(cast, exp.TryCast) and to:
1431            if to.this in exp.DataType.TEXT_TYPES and to.expressions:
1432                cast.set("null_on_text_overflow", True)
1433            elif to.this == exp.DType.DATE and cast.this.is_string:
1434                cast.set("probe_date_format", True)
1435        return cast
1436
1437    def _parse_window(self, this: exp.Expr | None, alias: bool = False) -> exp.Expr | None:
1438        result = super()._parse_window(this, alias)
1439
1440        # Set default window frame for ranking functions if not present
1441        if (
1442            isinstance(result, exp.Window)
1443            and isinstance(this, RANKING_WINDOW_FUNCTIONS_WITH_FRAME)
1444            and not result.args.get("spec")
1445        ):
1446            frame = exp.WindowSpec(
1447                kind="ROWS",
1448                start="UNBOUNDED",
1449                start_side="PRECEDING",
1450                end="UNBOUNDED",
1451                end_side="FOLLOWING",
1452            )
1453            result.set("spec", frame)
1454        return result
1455
1456
1457# This is imported and used by both the parser (above) and the generator in the dialect file
1458RANKING_WINDOW_FUNCTIONS_WITH_FRAME = (
1459    exp.FirstValue,
1460    exp.LastValue,
1461    exp.NthValue,
1462)
1463
1464
1465def build_object_construct(args: list) -> exp.StarMap | exp.Struct:
1466    expression = parser.build_var_map(args)
1467
1468    if isinstance(expression, exp.StarMap):
1469        return expression
1470
1471    return exp.Struct(
1472        expressions=[
1473            exp.PropertyEQ(this=k, expression=v) for k, v in zip(expression.keys, expression.values)
1474        ]
1475    )