sqlglot.parsers.snowflake

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