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