sqlglot.dialects.snowflake

   1from __future__ import annotations
   2
   3import typing as t
   4
   5from sqlglot import exp, generator, jsonpath, parser, tokens, transforms
   6from sqlglot.dialects.dialect import (
   7    Dialect,
   8    NormalizationStrategy,
   9    binary_from_function,
  10    build_default_decimal_type,
  11    build_timestamp_from_parts,
  12    date_delta_sql,
  13    date_trunc_to_time,
  14    datestrtodate_sql,
  15    build_formatted_time,
  16    if_sql,
  17    inline_array_sql,
  18    max_or_greatest,
  19    min_or_least,
  20    rename_func,
  21    timestamptrunc_sql,
  22    timestrtotime_sql,
  23    var_map_sql,
  24    map_date_part,
  25    no_safe_divide_sql,
  26    no_timestamp_sql,
  27    timestampdiff_sql,
  28    no_make_interval_sql,
  29)
  30from sqlglot.generator import unsupported_args
  31from sqlglot.helper import flatten, is_float, is_int, seq_get
  32from sqlglot.tokens import TokenType
  33
  34if t.TYPE_CHECKING:
  35    from sqlglot._typing import E, B
  36
  37
  38# from https://docs.snowflake.com/en/sql-reference/functions/to_timestamp.html
  39def _build_datetime(
  40    name: str, kind: exp.DataType.Type, safe: bool = False
  41) -> t.Callable[[t.List], exp.Func]:
  42    def _builder(args: t.List) -> exp.Func:
  43        value = seq_get(args, 0)
  44        scale_or_fmt = seq_get(args, 1)
  45
  46        int_value = value is not None and is_int(value.name)
  47        int_scale_or_fmt = scale_or_fmt is not None and scale_or_fmt.is_int
  48
  49        if isinstance(value, exp.Literal) or (value and scale_or_fmt):
  50            # Converts calls like `TO_TIME('01:02:03')` into casts
  51            if len(args) == 1 and value.is_string and not int_value:
  52                return (
  53                    exp.TryCast(this=value, to=exp.DataType.build(kind))
  54                    if safe
  55                    else exp.cast(value, kind)
  56                )
  57
  58            # Handles `TO_TIMESTAMP(str, fmt)` and `TO_TIMESTAMP(num, scale)` as special
  59            # cases so we can transpile them, since they're relatively common
  60            if kind == exp.DataType.Type.TIMESTAMP:
  61                if not safe and (int_value or int_scale_or_fmt):
  62                    # TRY_TO_TIMESTAMP('integer') is not parsed into exp.UnixToTime as
  63                    # it's not easily transpilable
  64                    return exp.UnixToTime(this=value, scale=scale_or_fmt)
  65                if not int_scale_or_fmt and not is_float(value.name):
  66                    expr = build_formatted_time(exp.StrToTime, "snowflake")(args)
  67                    expr.set("safe", safe)
  68                    return expr
  69
  70        if kind == exp.DataType.Type.DATE and not int_value:
  71            formatted_exp = build_formatted_time(exp.TsOrDsToDate, "snowflake")(args)
  72            formatted_exp.set("safe", safe)
  73            return formatted_exp
  74
  75        return exp.Anonymous(this=name, expressions=args)
  76
  77    return _builder
  78
  79
  80def _build_object_construct(args: t.List) -> t.Union[exp.StarMap, exp.Struct]:
  81    expression = parser.build_var_map(args)
  82
  83    if isinstance(expression, exp.StarMap):
  84        return expression
  85
  86    return exp.Struct(
  87        expressions=[
  88            exp.PropertyEQ(this=k, expression=v) for k, v in zip(expression.keys, expression.values)
  89        ]
  90    )
  91
  92
  93def _build_datediff(args: t.List) -> exp.DateDiff:
  94    return exp.DateDiff(
  95        this=seq_get(args, 2), expression=seq_get(args, 1), unit=map_date_part(seq_get(args, 0))
  96    )
  97
  98
  99def _build_date_time_add(expr_type: t.Type[E]) -> t.Callable[[t.List], E]:
 100    def _builder(args: t.List) -> E:
 101        return expr_type(
 102            this=seq_get(args, 2),
 103            expression=seq_get(args, 1),
 104            unit=map_date_part(seq_get(args, 0)),
 105        )
 106
 107    return _builder
 108
 109
 110def _build_bitwise(expr_type: t.Type[B], name: str) -> t.Callable[[t.List], B | exp.Anonymous]:
 111    def _builder(args: t.List) -> B | exp.Anonymous:
 112        if len(args) == 3:
 113            return exp.Anonymous(this=name, expressions=args)
 114
 115        return binary_from_function(expr_type)(args)
 116
 117    return _builder
 118
 119
 120# https://docs.snowflake.com/en/sql-reference/functions/div0
 121def _build_if_from_div0(args: t.List) -> exp.If:
 122    lhs = exp._wrap(seq_get(args, 0), exp.Binary)
 123    rhs = exp._wrap(seq_get(args, 1), exp.Binary)
 124
 125    cond = exp.EQ(this=rhs, expression=exp.Literal.number(0)).and_(
 126        exp.Is(this=lhs, expression=exp.null()).not_()
 127    )
 128    true = exp.Literal.number(0)
 129    false = exp.Div(this=lhs, expression=rhs)
 130    return exp.If(this=cond, true=true, false=false)
 131
 132
 133# https://docs.snowflake.com/en/sql-reference/functions/zeroifnull
 134def _build_if_from_zeroifnull(args: t.List) -> exp.If:
 135    cond = exp.Is(this=seq_get(args, 0), expression=exp.Null())
 136    return exp.If(this=cond, true=exp.Literal.number(0), false=seq_get(args, 0))
 137
 138
 139# https://docs.snowflake.com/en/sql-reference/functions/zeroifnull
 140def _build_if_from_nullifzero(args: t.List) -> exp.If:
 141    cond = exp.EQ(this=seq_get(args, 0), expression=exp.Literal.number(0))
 142    return exp.If(this=cond, true=exp.Null(), false=seq_get(args, 0))
 143
 144
 145def _regexpilike_sql(self: Snowflake.Generator, expression: exp.RegexpILike) -> str:
 146    flag = expression.text("flag")
 147
 148    if "i" not in flag:
 149        flag += "i"
 150
 151    return self.func(
 152        "REGEXP_LIKE", expression.this, expression.expression, exp.Literal.string(flag)
 153    )
 154
 155
 156def _build_regexp_replace(args: t.List) -> exp.RegexpReplace:
 157    regexp_replace = exp.RegexpReplace.from_arg_list(args)
 158
 159    if not regexp_replace.args.get("replacement"):
 160        regexp_replace.set("replacement", exp.Literal.string(""))
 161
 162    return regexp_replace
 163
 164
 165def _show_parser(*args: t.Any, **kwargs: t.Any) -> t.Callable[[Snowflake.Parser], exp.Show]:
 166    def _parse(self: Snowflake.Parser) -> exp.Show:
 167        return self._parse_show_snowflake(*args, **kwargs)
 168
 169    return _parse
 170
 171
 172def _date_trunc_to_time(args: t.List) -> exp.DateTrunc | exp.TimestampTrunc:
 173    trunc = date_trunc_to_time(args)
 174    trunc.set("unit", map_date_part(trunc.args["unit"]))
 175    return trunc
 176
 177
 178def _unqualify_unpivot_columns(expression: exp.Expression) -> exp.Expression:
 179    """
 180    Snowflake doesn't allow columns referenced in UNPIVOT to be qualified,
 181    so we need to unqualify them.
 182
 183    Example:
 184        >>> from sqlglot import parse_one
 185        >>> expr = parse_one("SELECT * FROM m_sales UNPIVOT(sales FOR month IN (m_sales.jan, feb, mar, april))")
 186        >>> print(_unqualify_unpivot_columns(expr).sql(dialect="snowflake"))
 187        SELECT * FROM m_sales UNPIVOT(sales FOR month IN (jan, feb, mar, april))
 188    """
 189    if isinstance(expression, exp.Pivot) and expression.unpivot:
 190        expression = transforms.unqualify_columns(expression)
 191
 192    return expression
 193
 194
 195def _flatten_structured_types_unless_iceberg(expression: exp.Expression) -> exp.Expression:
 196    assert isinstance(expression, exp.Create)
 197
 198    def _flatten_structured_type(expression: exp.DataType) -> exp.DataType:
 199        if expression.this in exp.DataType.NESTED_TYPES:
 200            expression.set("expressions", None)
 201        return expression
 202
 203    props = expression.args.get("properties")
 204    if isinstance(expression.this, exp.Schema) and not (props and props.find(exp.IcebergProperty)):
 205        for schema_expression in expression.this.expressions:
 206            if isinstance(schema_expression, exp.ColumnDef):
 207                column_type = schema_expression.kind
 208                if isinstance(column_type, exp.DataType):
 209                    column_type.transform(_flatten_structured_type, copy=False)
 210
 211    return expression
 212
 213
 214def _unnest_generate_date_array(unnest: exp.Unnest) -> None:
 215    generate_date_array = unnest.expressions[0]
 216    start = generate_date_array.args.get("start")
 217    end = generate_date_array.args.get("end")
 218    step = generate_date_array.args.get("step")
 219
 220    if not start or not end or not isinstance(step, exp.Interval) or step.name != "1":
 221        return
 222
 223    unit = step.args.get("unit")
 224
 225    unnest_alias = unnest.args.get("alias")
 226    if unnest_alias:
 227        unnest_alias = unnest_alias.copy()
 228        sequence_value_name = seq_get(unnest_alias.columns, 0) or "value"
 229    else:
 230        sequence_value_name = "value"
 231
 232    # We'll add the next sequence value to the starting date and project the result
 233    date_add = _build_date_time_add(exp.DateAdd)(
 234        [unit, exp.cast(sequence_value_name, "int"), exp.cast(start, "date")]
 235    ).as_(sequence_value_name)
 236
 237    # We use DATEDIFF to compute the number of sequence values needed
 238    number_sequence = Snowflake.Parser.FUNCTIONS["ARRAY_GENERATE_RANGE"](
 239        [exp.Literal.number(0), _build_datediff([unit, start, end]) + 1]
 240    )
 241
 242    unnest.set("expressions", [number_sequence])
 243    unnest.replace(exp.select(date_add).from_(unnest.copy()).subquery(unnest_alias))
 244
 245
 246def _transform_generate_date_array(expression: exp.Expression) -> exp.Expression:
 247    if isinstance(expression, exp.Select):
 248        for generate_date_array in expression.find_all(exp.GenerateDateArray):
 249            parent = generate_date_array.parent
 250
 251            # If GENERATE_DATE_ARRAY is used directly as an array (e.g passed into ARRAY_LENGTH), the transformed Snowflake
 252            # query is the following (it'll be unnested properly on the next iteration due to copy):
 253            # SELECT ref(GENERATE_DATE_ARRAY(...)) -> SELECT ref((SELECT ARRAY_AGG(*) FROM UNNEST(GENERATE_DATE_ARRAY(...))))
 254            if not isinstance(parent, exp.Unnest):
 255                unnest = exp.Unnest(expressions=[generate_date_array.copy()])
 256                generate_date_array.replace(
 257                    exp.select(exp.ArrayAgg(this=exp.Star())).from_(unnest).subquery()
 258                )
 259
 260            if (
 261                isinstance(parent, exp.Unnest)
 262                and isinstance(parent.parent, (exp.From, exp.Join))
 263                and len(parent.expressions) == 1
 264            ):
 265                _unnest_generate_date_array(parent)
 266
 267    return expression
 268
 269
 270def _build_regexp_extract(expr_type: t.Type[E]) -> t.Callable[[t.List], E]:
 271    def _builder(args: t.List) -> E:
 272        return expr_type(
 273            this=seq_get(args, 0),
 274            expression=seq_get(args, 1),
 275            position=seq_get(args, 2),
 276            occurrence=seq_get(args, 3),
 277            parameters=seq_get(args, 4),
 278            group=seq_get(args, 5) or exp.Literal.number(0),
 279        )
 280
 281    return _builder
 282
 283
 284def _regexpextract_sql(self, expression: exp.RegexpExtract | exp.RegexpExtractAll) -> str:
 285    # Other dialects don't support all of the following parameters, so we need to
 286    # generate default values as necessary to ensure the transpilation is correct
 287    group = expression.args.get("group")
 288
 289    # To avoid generating all these default values, we set group to None if
 290    # it's 0 (also default value) which doesn't trigger the following chain
 291    if group and group.name == "0":
 292        group = None
 293
 294    parameters = expression.args.get("parameters") or (group and exp.Literal.string("c"))
 295    occurrence = expression.args.get("occurrence") or (parameters and exp.Literal.number(1))
 296    position = expression.args.get("position") or (occurrence and exp.Literal.number(1))
 297
 298    return self.func(
 299        "REGEXP_SUBSTR" if isinstance(expression, exp.RegexpExtract) else "REGEXP_EXTRACT_ALL",
 300        expression.this,
 301        expression.expression,
 302        position,
 303        occurrence,
 304        parameters,
 305        group,
 306    )
 307
 308
 309def _json_extract_value_array_sql(
 310    self: Snowflake.Generator, expression: exp.JSONValueArray | exp.JSONExtractArray
 311) -> str:
 312    json_extract = exp.JSONExtract(this=expression.this, expression=expression.expression)
 313    ident = exp.to_identifier("x")
 314
 315    if isinstance(expression, exp.JSONValueArray):
 316        this: exp.Expression = exp.cast(ident, to=exp.DataType.Type.VARCHAR)
 317    else:
 318        this = exp.ParseJSON(this=f"TO_JSON({ident})")
 319
 320    transform_lambda = exp.Lambda(expressions=[ident], this=this)
 321
 322    return self.func("TRANSFORM", json_extract, transform_lambda)
 323
 324
 325class Snowflake(Dialect):
 326    # https://docs.snowflake.com/en/sql-reference/identifiers-syntax
 327    NORMALIZATION_STRATEGY = NormalizationStrategy.UPPERCASE
 328    NULL_ORDERING = "nulls_are_large"
 329    TIME_FORMAT = "'YYYY-MM-DD HH24:MI:SS'"
 330    SUPPORTS_USER_DEFINED_TYPES = False
 331    SUPPORTS_SEMI_ANTI_JOIN = False
 332    PREFER_CTE_ALIAS_COLUMN = True
 333    TABLESAMPLE_SIZE_IS_PERCENT = True
 334    COPY_PARAMS_ARE_CSV = False
 335    ARRAY_AGG_INCLUDES_NULLS = None
 336
 337    TIME_MAPPING = {
 338        "YYYY": "%Y",
 339        "yyyy": "%Y",
 340        "YY": "%y",
 341        "yy": "%y",
 342        "MMMM": "%B",
 343        "mmmm": "%B",
 344        "MON": "%b",
 345        "mon": "%b",
 346        "MM": "%m",
 347        "mm": "%m",
 348        "DD": "%d",
 349        "dd": "%-d",
 350        "DY": "%a",
 351        "dy": "%w",
 352        "HH24": "%H",
 353        "hh24": "%H",
 354        "HH12": "%I",
 355        "hh12": "%I",
 356        "MI": "%M",
 357        "mi": "%M",
 358        "SS": "%S",
 359        "ss": "%S",
 360        "FF": "%f",
 361        "ff": "%f",
 362        "FF6": "%f",
 363        "ff6": "%f",
 364    }
 365
 366    def quote_identifier(self, expression: E, identify: bool = True) -> E:
 367        # This disables quoting DUAL in SELECT ... FROM DUAL, because Snowflake treats an
 368        # unquoted DUAL keyword in a special way and does not map it to a user-defined table
 369        if (
 370            isinstance(expression, exp.Identifier)
 371            and isinstance(expression.parent, exp.Table)
 372            and expression.name.lower() == "dual"
 373        ):
 374            return expression  # type: ignore
 375
 376        return super().quote_identifier(expression, identify=identify)
 377
 378    class JSONPathTokenizer(jsonpath.JSONPathTokenizer):
 379        SINGLE_TOKENS = jsonpath.JSONPathTokenizer.SINGLE_TOKENS.copy()
 380        SINGLE_TOKENS.pop("$")
 381
 382    class Parser(parser.Parser):
 383        IDENTIFY_PIVOT_STRINGS = True
 384        DEFAULT_SAMPLING_METHOD = "BERNOULLI"
 385        COLON_IS_VARIANT_EXTRACT = True
 386
 387        ID_VAR_TOKENS = {
 388            *parser.Parser.ID_VAR_TOKENS,
 389            TokenType.MATCH_CONDITION,
 390        }
 391
 392        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS | {TokenType.WINDOW}
 393        TABLE_ALIAS_TOKENS.discard(TokenType.MATCH_CONDITION)
 394
 395        FUNCTIONS = {
 396            **parser.Parser.FUNCTIONS,
 397            "APPROX_PERCENTILE": exp.ApproxQuantile.from_arg_list,
 398            "ARRAY_CONSTRUCT": lambda args: exp.Array(expressions=args),
 399            "ARRAY_CONTAINS": lambda args: exp.ArrayContains(
 400                this=seq_get(args, 1), expression=seq_get(args, 0)
 401            ),
 402            "ARRAY_GENERATE_RANGE": lambda args: exp.GenerateSeries(
 403                # ARRAY_GENERATE_RANGE has an exlusive end; we normalize it to be inclusive
 404                start=seq_get(args, 0),
 405                end=exp.Sub(this=seq_get(args, 1), expression=exp.Literal.number(1)),
 406                step=seq_get(args, 2),
 407            ),
 408            "BITXOR": _build_bitwise(exp.BitwiseXor, "BITXOR"),
 409            "BIT_XOR": _build_bitwise(exp.BitwiseXor, "BITXOR"),
 410            "BITOR": _build_bitwise(exp.BitwiseOr, "BITOR"),
 411            "BIT_OR": _build_bitwise(exp.BitwiseOr, "BITOR"),
 412            "BITSHIFTLEFT": _build_bitwise(exp.BitwiseLeftShift, "BITSHIFTLEFT"),
 413            "BIT_SHIFTLEFT": _build_bitwise(exp.BitwiseLeftShift, "BIT_SHIFTLEFT"),
 414            "BITSHIFTRIGHT": _build_bitwise(exp.BitwiseRightShift, "BITSHIFTRIGHT"),
 415            "BIT_SHIFTRIGHT": _build_bitwise(exp.BitwiseRightShift, "BIT_SHIFTRIGHT"),
 416            "BOOLXOR": _build_bitwise(exp.Xor, "BOOLXOR"),
 417            "DATE": _build_datetime("DATE", exp.DataType.Type.DATE),
 418            "DATE_TRUNC": _date_trunc_to_time,
 419            "DATEADD": _build_date_time_add(exp.DateAdd),
 420            "DATEDIFF": _build_datediff,
 421            "DIV0": _build_if_from_div0,
 422            "EDITDISTANCE": lambda args: exp.Levenshtein(
 423                this=seq_get(args, 0), expression=seq_get(args, 1), max_dist=seq_get(args, 2)
 424            ),
 425            "FLATTEN": exp.Explode.from_arg_list,
 426            "GET_PATH": lambda args, dialect: exp.JSONExtract(
 427                this=seq_get(args, 0), expression=dialect.to_json_path(seq_get(args, 1))
 428            ),
 429            "IFF": exp.If.from_arg_list,
 430            "LAST_DAY": lambda args: exp.LastDay(
 431                this=seq_get(args, 0), unit=map_date_part(seq_get(args, 1))
 432            ),
 433            "LEN": lambda args: exp.Length(this=seq_get(args, 0), binary=True),
 434            "LENGTH": lambda args: exp.Length(this=seq_get(args, 0), binary=True),
 435            "LISTAGG": exp.GroupConcat.from_arg_list,
 436            "NULLIFZERO": _build_if_from_nullifzero,
 437            "OBJECT_CONSTRUCT": _build_object_construct,
 438            "REGEXP_EXTRACT_ALL": _build_regexp_extract(exp.RegexpExtractAll),
 439            "REGEXP_REPLACE": _build_regexp_replace,
 440            "REGEXP_SUBSTR": _build_regexp_extract(exp.RegexpExtract),
 441            "REGEXP_SUBSTR_ALL": _build_regexp_extract(exp.RegexpExtractAll),
 442            "RLIKE": exp.RegexpLike.from_arg_list,
 443            "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)),
 444            "TIMEADD": _build_date_time_add(exp.TimeAdd),
 445            "TIMEDIFF": _build_datediff,
 446            "TIMESTAMPADD": _build_date_time_add(exp.DateAdd),
 447            "TIMESTAMPDIFF": _build_datediff,
 448            "TIMESTAMPFROMPARTS": build_timestamp_from_parts,
 449            "TIMESTAMP_FROM_PARTS": build_timestamp_from_parts,
 450            "TIMESTAMPNTZFROMPARTS": build_timestamp_from_parts,
 451            "TIMESTAMP_NTZ_FROM_PARTS": build_timestamp_from_parts,
 452            "TRY_PARSE_JSON": lambda args: exp.ParseJSON(this=seq_get(args, 0), safe=True),
 453            "TRY_TO_DATE": _build_datetime("TRY_TO_DATE", exp.DataType.Type.DATE, safe=True),
 454            "TRY_TO_TIMESTAMP": _build_datetime(
 455                "TRY_TO_TIMESTAMP", exp.DataType.Type.TIMESTAMP, safe=True
 456            ),
 457            "TO_DATE": _build_datetime("TO_DATE", exp.DataType.Type.DATE),
 458            "TO_NUMBER": lambda args: exp.ToNumber(
 459                this=seq_get(args, 0),
 460                format=seq_get(args, 1),
 461                precision=seq_get(args, 2),
 462                scale=seq_get(args, 3),
 463            ),
 464            "TO_TIME": _build_datetime("TO_TIME", exp.DataType.Type.TIME),
 465            "TO_TIMESTAMP": _build_datetime("TO_TIMESTAMP", exp.DataType.Type.TIMESTAMP),
 466            "TO_TIMESTAMP_LTZ": _build_datetime("TO_TIMESTAMP_LTZ", exp.DataType.Type.TIMESTAMPLTZ),
 467            "TO_TIMESTAMP_NTZ": _build_datetime("TO_TIMESTAMP_NTZ", exp.DataType.Type.TIMESTAMP),
 468            "TO_TIMESTAMP_TZ": _build_datetime("TO_TIMESTAMP_TZ", exp.DataType.Type.TIMESTAMPTZ),
 469            "TO_VARCHAR": exp.ToChar.from_arg_list,
 470            "ZEROIFNULL": _build_if_from_zeroifnull,
 471        }
 472
 473        FUNCTION_PARSERS = {
 474            **parser.Parser.FUNCTION_PARSERS,
 475            "DATE_PART": lambda self: self._parse_date_part(),
 476            "OBJECT_CONSTRUCT_KEEP_NULL": lambda self: self._parse_json_object(),
 477        }
 478        FUNCTION_PARSERS.pop("TRIM")
 479
 480        TIMESTAMPS = parser.Parser.TIMESTAMPS - {TokenType.TIME}
 481
 482        RANGE_PARSERS = {
 483            **parser.Parser.RANGE_PARSERS,
 484            TokenType.LIKE_ANY: parser.binary_range_parser(exp.LikeAny),
 485            TokenType.ILIKE_ANY: parser.binary_range_parser(exp.ILikeAny),
 486        }
 487
 488        ALTER_PARSERS = {
 489            **parser.Parser.ALTER_PARSERS,
 490            "UNSET": lambda self: self.expression(
 491                exp.Set,
 492                tag=self._match_text_seq("TAG"),
 493                expressions=self._parse_csv(self._parse_id_var),
 494                unset=True,
 495            ),
 496        }
 497
 498        STATEMENT_PARSERS = {
 499            **parser.Parser.STATEMENT_PARSERS,
 500            TokenType.SHOW: lambda self: self._parse_show(),
 501        }
 502
 503        PROPERTY_PARSERS = {
 504            **parser.Parser.PROPERTY_PARSERS,
 505            "LOCATION": lambda self: self._parse_location_property(),
 506            "TAG": lambda self: self._parse_tag(),
 507        }
 508
 509        TYPE_CONVERTERS = {
 510            # https://docs.snowflake.com/en/sql-reference/data-types-numeric#number
 511            exp.DataType.Type.DECIMAL: build_default_decimal_type(precision=38, scale=0),
 512        }
 513
 514        SHOW_PARSERS = {
 515            "SCHEMAS": _show_parser("SCHEMAS"),
 516            "TERSE SCHEMAS": _show_parser("SCHEMAS"),
 517            "OBJECTS": _show_parser("OBJECTS"),
 518            "TERSE OBJECTS": _show_parser("OBJECTS"),
 519            "TABLES": _show_parser("TABLES"),
 520            "TERSE TABLES": _show_parser("TABLES"),
 521            "VIEWS": _show_parser("VIEWS"),
 522            "TERSE VIEWS": _show_parser("VIEWS"),
 523            "PRIMARY KEYS": _show_parser("PRIMARY KEYS"),
 524            "TERSE PRIMARY KEYS": _show_parser("PRIMARY KEYS"),
 525            "IMPORTED KEYS": _show_parser("IMPORTED KEYS"),
 526            "TERSE IMPORTED KEYS": _show_parser("IMPORTED KEYS"),
 527            "UNIQUE KEYS": _show_parser("UNIQUE KEYS"),
 528            "TERSE UNIQUE KEYS": _show_parser("UNIQUE KEYS"),
 529            "SEQUENCES": _show_parser("SEQUENCES"),
 530            "TERSE SEQUENCES": _show_parser("SEQUENCES"),
 531            "COLUMNS": _show_parser("COLUMNS"),
 532            "USERS": _show_parser("USERS"),
 533            "TERSE USERS": _show_parser("USERS"),
 534        }
 535
 536        CONSTRAINT_PARSERS = {
 537            **parser.Parser.CONSTRAINT_PARSERS,
 538            "WITH": lambda self: self._parse_with_constraint(),
 539            "MASKING": lambda self: self._parse_with_constraint(),
 540            "PROJECTION": lambda self: self._parse_with_constraint(),
 541            "TAG": lambda self: self._parse_with_constraint(),
 542        }
 543
 544        STAGED_FILE_SINGLE_TOKENS = {
 545            TokenType.DOT,
 546            TokenType.MOD,
 547            TokenType.SLASH,
 548        }
 549
 550        FLATTEN_COLUMNS = ["SEQ", "KEY", "PATH", "INDEX", "VALUE", "THIS"]
 551
 552        SCHEMA_KINDS = {"OBJECTS", "TABLES", "VIEWS", "SEQUENCES", "UNIQUE KEYS", "IMPORTED KEYS"}
 553
 554        NON_TABLE_CREATABLES = {"STORAGE INTEGRATION", "TAG", "WAREHOUSE", "STREAMLIT"}
 555
 556        LAMBDAS = {
 557            **parser.Parser.LAMBDAS,
 558            TokenType.ARROW: lambda self, expressions: self.expression(
 559                exp.Lambda,
 560                this=self._replace_lambda(
 561                    self._parse_assignment(),
 562                    expressions,
 563                ),
 564                expressions=[e.this if isinstance(e, exp.Cast) else e for e in expressions],
 565            ),
 566        }
 567
 568        def _negate_range(
 569            self, this: t.Optional[exp.Expression] = None
 570        ) -> t.Optional[exp.Expression]:
 571            if not this:
 572                return this
 573
 574            query = this.args.get("query")
 575            if isinstance(this, exp.In) and isinstance(query, exp.Query):
 576                # Snowflake treats `value NOT IN (subquery)` as `VALUE <> ALL (subquery)`, so
 577                # we do this conversion here to avoid parsing it into `NOT value IN (subquery)`
 578                # which can produce different results (most likely a SnowFlake bug).
 579                #
 580                # https://docs.snowflake.com/en/sql-reference/functions/in
 581                # Context: https://github.com/tobymao/sqlglot/issues/3890
 582                return self.expression(
 583                    exp.NEQ, this=this.this, expression=exp.All(this=query.unnest())
 584                )
 585
 586            return self.expression(exp.Not, this=this)
 587
 588        def _parse_tag(self) -> exp.Tags:
 589            return self.expression(
 590                exp.Tags,
 591                expressions=self._parse_wrapped_csv(self._parse_property),
 592            )
 593
 594        def _parse_with_constraint(self) -> t.Optional[exp.Expression]:
 595            if self._prev.token_type != TokenType.WITH:
 596                self._retreat(self._index - 1)
 597
 598            if self._match_text_seq("MASKING", "POLICY"):
 599                policy = self._parse_column()
 600                return self.expression(
 601                    exp.MaskingPolicyColumnConstraint,
 602                    this=policy.to_dot() if isinstance(policy, exp.Column) else policy,
 603                    expressions=self._match(TokenType.USING)
 604                    and self._parse_wrapped_csv(self._parse_id_var),
 605                )
 606            if self._match_text_seq("PROJECTION", "POLICY"):
 607                policy = self._parse_column()
 608                return self.expression(
 609                    exp.ProjectionPolicyColumnConstraint,
 610                    this=policy.to_dot() if isinstance(policy, exp.Column) else policy,
 611                )
 612            if self._match(TokenType.TAG):
 613                return self._parse_tag()
 614
 615            return None
 616
 617        def _parse_with_property(self) -> t.Optional[exp.Expression] | t.List[exp.Expression]:
 618            if self._match(TokenType.TAG):
 619                return self._parse_tag()
 620
 621            return super()._parse_with_property()
 622
 623        def _parse_create(self) -> exp.Create | exp.Command:
 624            expression = super()._parse_create()
 625            if isinstance(expression, exp.Create) and expression.kind in self.NON_TABLE_CREATABLES:
 626                # Replace the Table node with the enclosed Identifier
 627                expression.this.replace(expression.this.this)
 628
 629            return expression
 630
 631        # https://docs.snowflake.com/en/sql-reference/functions/date_part.html
 632        # https://docs.snowflake.com/en/sql-reference/functions-date-time.html#label-supported-date-time-parts
 633        def _parse_date_part(self: Snowflake.Parser) -> t.Optional[exp.Expression]:
 634            this = self._parse_var() or self._parse_type()
 635
 636            if not this:
 637                return None
 638
 639            self._match(TokenType.COMMA)
 640            expression = self._parse_bitwise()
 641            this = map_date_part(this)
 642            name = this.name.upper()
 643
 644            if name.startswith("EPOCH"):
 645                if name == "EPOCH_MILLISECOND":
 646                    scale = 10**3
 647                elif name == "EPOCH_MICROSECOND":
 648                    scale = 10**6
 649                elif name == "EPOCH_NANOSECOND":
 650                    scale = 10**9
 651                else:
 652                    scale = None
 653
 654                ts = self.expression(exp.Cast, this=expression, to=exp.DataType.build("TIMESTAMP"))
 655                to_unix: exp.Expression = self.expression(exp.TimeToUnix, this=ts)
 656
 657                if scale:
 658                    to_unix = exp.Mul(this=to_unix, expression=exp.Literal.number(scale))
 659
 660                return to_unix
 661
 662            return self.expression(exp.Extract, this=this, expression=expression)
 663
 664        def _parse_bracket_key_value(self, is_map: bool = False) -> t.Optional[exp.Expression]:
 665            if is_map:
 666                # Keys are strings in Snowflake's objects, see also:
 667                # - https://docs.snowflake.com/en/sql-reference/data-types-semistructured
 668                # - https://docs.snowflake.com/en/sql-reference/functions/object_construct
 669                return self._parse_slice(self._parse_string())
 670
 671            return self._parse_slice(self._parse_alias(self._parse_assignment(), explicit=True))
 672
 673        def _parse_lateral(self) -> t.Optional[exp.Lateral]:
 674            lateral = super()._parse_lateral()
 675            if not lateral:
 676                return lateral
 677
 678            if isinstance(lateral.this, exp.Explode):
 679                table_alias = lateral.args.get("alias")
 680                columns = [exp.to_identifier(col) for col in self.FLATTEN_COLUMNS]
 681                if table_alias and not table_alias.args.get("columns"):
 682                    table_alias.set("columns", columns)
 683                elif not table_alias:
 684                    exp.alias_(lateral, "_flattened", table=columns, copy=False)
 685
 686            return lateral
 687
 688        def _parse_table_parts(
 689            self, schema: bool = False, is_db_reference: bool = False, wildcard: bool = False
 690        ) -> exp.Table:
 691            # https://docs.snowflake.com/en/user-guide/querying-stage
 692            if self._match(TokenType.STRING, advance=False):
 693                table = self._parse_string()
 694            elif self._match_text_seq("@", advance=False):
 695                table = self._parse_location_path()
 696            else:
 697                table = None
 698
 699            if table:
 700                file_format = None
 701                pattern = None
 702
 703                wrapped = self._match(TokenType.L_PAREN)
 704                while self._curr and wrapped and not self._match(TokenType.R_PAREN):
 705                    if self._match_text_seq("FILE_FORMAT", "=>"):
 706                        file_format = self._parse_string() or super()._parse_table_parts(
 707                            is_db_reference=is_db_reference
 708                        )
 709                    elif self._match_text_seq("PATTERN", "=>"):
 710                        pattern = self._parse_string()
 711                    else:
 712                        break
 713
 714                    self._match(TokenType.COMMA)
 715
 716                table = self.expression(exp.Table, this=table, format=file_format, pattern=pattern)
 717            else:
 718                table = super()._parse_table_parts(schema=schema, is_db_reference=is_db_reference)
 719
 720            return table
 721
 722        def _parse_id_var(
 723            self,
 724            any_token: bool = True,
 725            tokens: t.Optional[t.Collection[TokenType]] = None,
 726        ) -> t.Optional[exp.Expression]:
 727            if self._match_text_seq("IDENTIFIER", "("):
 728                identifier = (
 729                    super()._parse_id_var(any_token=any_token, tokens=tokens)
 730                    or self._parse_string()
 731                )
 732                self._match_r_paren()
 733                return self.expression(exp.Anonymous, this="IDENTIFIER", expressions=[identifier])
 734
 735            return super()._parse_id_var(any_token=any_token, tokens=tokens)
 736
 737        def _parse_show_snowflake(self, this: str) -> exp.Show:
 738            scope = None
 739            scope_kind = None
 740
 741            # will identity SHOW TERSE SCHEMAS but not SHOW TERSE PRIMARY KEYS
 742            # which is syntactically valid but has no effect on the output
 743            terse = self._tokens[self._index - 2].text.upper() == "TERSE"
 744
 745            history = self._match_text_seq("HISTORY")
 746
 747            like = self._parse_string() if self._match(TokenType.LIKE) else None
 748
 749            if self._match(TokenType.IN):
 750                if self._match_text_seq("ACCOUNT"):
 751                    scope_kind = "ACCOUNT"
 752                elif self._match_set(self.DB_CREATABLES):
 753                    scope_kind = self._prev.text.upper()
 754                    if self._curr:
 755                        scope = self._parse_table_parts()
 756                elif self._curr:
 757                    scope_kind = "SCHEMA" if this in self.SCHEMA_KINDS else "TABLE"
 758                    scope = self._parse_table_parts()
 759
 760            return self.expression(
 761                exp.Show,
 762                **{
 763                    "terse": terse,
 764                    "this": this,
 765                    "history": history,
 766                    "like": like,
 767                    "scope": scope,
 768                    "scope_kind": scope_kind,
 769                    "starts_with": self._match_text_seq("STARTS", "WITH") and self._parse_string(),
 770                    "limit": self._parse_limit(),
 771                    "from": self._parse_string() if self._match(TokenType.FROM) else None,
 772                },
 773            )
 774
 775        def _parse_location_property(self) -> exp.LocationProperty:
 776            self._match(TokenType.EQ)
 777            return self.expression(exp.LocationProperty, this=self._parse_location_path())
 778
 779        def _parse_file_location(self) -> t.Optional[exp.Expression]:
 780            # Parse either a subquery or a staged file
 781            return (
 782                self._parse_select(table=True, parse_subquery_alias=False)
 783                if self._match(TokenType.L_PAREN, advance=False)
 784                else self._parse_table_parts()
 785            )
 786
 787        def _parse_location_path(self) -> exp.Var:
 788            parts = [self._advance_any(ignore_reserved=True)]
 789
 790            # We avoid consuming a comma token because external tables like @foo and @bar
 791            # can be joined in a query with a comma separator, as well as closing paren
 792            # in case of subqueries
 793            while self._is_connected() and not self._match_set(
 794                (TokenType.COMMA, TokenType.L_PAREN, TokenType.R_PAREN), advance=False
 795            ):
 796                parts.append(self._advance_any(ignore_reserved=True))
 797
 798            return exp.var("".join(part.text for part in parts if part))
 799
 800        def _parse_lambda_arg(self) -> t.Optional[exp.Expression]:
 801            this = super()._parse_lambda_arg()
 802
 803            if not this:
 804                return this
 805
 806            typ = self._parse_types()
 807
 808            if typ:
 809                return self.expression(exp.Cast, this=this, to=typ)
 810
 811            return this
 812
 813        def _parse_foreign_key(self) -> exp.ForeignKey:
 814            # inlineFK, the REFERENCES columns are implied
 815            if self._match(TokenType.REFERENCES, advance=False):
 816                return self.expression(exp.ForeignKey)
 817
 818            # outoflineFK, explicitly names the columns
 819            return super()._parse_foreign_key()
 820
 821    class Tokenizer(tokens.Tokenizer):
 822        STRING_ESCAPES = ["\\", "'"]
 823        HEX_STRINGS = [("x'", "'"), ("X'", "'")]
 824        RAW_STRINGS = ["$$"]
 825        COMMENTS = ["--", "//", ("/*", "*/")]
 826        NESTED_COMMENTS = False
 827
 828        KEYWORDS = {
 829            **tokens.Tokenizer.KEYWORDS,
 830            "BYTEINT": TokenType.INT,
 831            "CHAR VARYING": TokenType.VARCHAR,
 832            "CHARACTER VARYING": TokenType.VARCHAR,
 833            "EXCLUDE": TokenType.EXCEPT,
 834            "ILIKE ANY": TokenType.ILIKE_ANY,
 835            "LIKE ANY": TokenType.LIKE_ANY,
 836            "MATCH_CONDITION": TokenType.MATCH_CONDITION,
 837            "MATCH_RECOGNIZE": TokenType.MATCH_RECOGNIZE,
 838            "MINUS": TokenType.EXCEPT,
 839            "NCHAR VARYING": TokenType.VARCHAR,
 840            "PUT": TokenType.COMMAND,
 841            "REMOVE": TokenType.COMMAND,
 842            "RM": TokenType.COMMAND,
 843            "SAMPLE": TokenType.TABLE_SAMPLE,
 844            "SQL_DOUBLE": TokenType.DOUBLE,
 845            "SQL_VARCHAR": TokenType.VARCHAR,
 846            "STORAGE INTEGRATION": TokenType.STORAGE_INTEGRATION,
 847            "TAG": TokenType.TAG,
 848            "TIMESTAMP_TZ": TokenType.TIMESTAMPTZ,
 849            "TOP": TokenType.TOP,
 850            "WAREHOUSE": TokenType.WAREHOUSE,
 851            "STREAMLIT": TokenType.STREAMLIT,
 852        }
 853        KEYWORDS.pop("/*+")
 854
 855        SINGLE_TOKENS = {
 856            **tokens.Tokenizer.SINGLE_TOKENS,
 857            "$": TokenType.PARAMETER,
 858        }
 859
 860        VAR_SINGLE_TOKENS = {"$"}
 861
 862        COMMANDS = tokens.Tokenizer.COMMANDS - {TokenType.SHOW}
 863
 864    class Generator(generator.Generator):
 865        PARAMETER_TOKEN = "$"
 866        MATCHED_BY_SOURCE = False
 867        SINGLE_STRING_INTERVAL = True
 868        JOIN_HINTS = False
 869        TABLE_HINTS = False
 870        QUERY_HINTS = False
 871        AGGREGATE_FILTER_SUPPORTED = False
 872        SUPPORTS_TABLE_COPY = False
 873        COLLATE_IS_FUNC = True
 874        LIMIT_ONLY_LITERALS = True
 875        JSON_KEY_VALUE_PAIR_SEP = ","
 876        INSERT_OVERWRITE = " OVERWRITE INTO"
 877        STRUCT_DELIMITER = ("(", ")")
 878        COPY_PARAMS_ARE_WRAPPED = False
 879        COPY_PARAMS_EQ_REQUIRED = True
 880        STAR_EXCEPT = "EXCLUDE"
 881        SUPPORTS_EXPLODING_PROJECTIONS = False
 882        ARRAY_CONCAT_IS_VAR_LEN = False
 883        SUPPORTS_CONVERT_TIMEZONE = True
 884        EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE = False
 885        SUPPORTS_MEDIAN = True
 886        ARRAY_SIZE_NAME = "ARRAY_SIZE"
 887
 888        TRANSFORMS = {
 889            **generator.Generator.TRANSFORMS,
 890            exp.ApproxDistinct: rename_func("APPROX_COUNT_DISTINCT"),
 891            exp.ArgMax: rename_func("MAX_BY"),
 892            exp.ArgMin: rename_func("MIN_BY"),
 893            exp.Array: inline_array_sql,
 894            exp.ArrayConcat: lambda self, e: self.arrayconcat_sql(e, name="ARRAY_CAT"),
 895            exp.ArrayContains: lambda self, e: self.func("ARRAY_CONTAINS", e.expression, e.this),
 896            exp.AtTimeZone: lambda self, e: self.func(
 897                "CONVERT_TIMEZONE", e.args.get("zone"), e.this
 898            ),
 899            exp.BitwiseOr: rename_func("BITOR"),
 900            exp.BitwiseXor: rename_func("BITXOR"),
 901            exp.BitwiseLeftShift: rename_func("BITSHIFTLEFT"),
 902            exp.BitwiseRightShift: rename_func("BITSHIFTRIGHT"),
 903            exp.Create: transforms.preprocess([_flatten_structured_types_unless_iceberg]),
 904            exp.DateAdd: date_delta_sql("DATEADD"),
 905            exp.DateDiff: date_delta_sql("DATEDIFF"),
 906            exp.DatetimeAdd: date_delta_sql("TIMESTAMPADD"),
 907            exp.DatetimeDiff: timestampdiff_sql,
 908            exp.DateStrToDate: datestrtodate_sql,
 909            exp.DayOfMonth: rename_func("DAYOFMONTH"),
 910            exp.DayOfWeek: rename_func("DAYOFWEEK"),
 911            exp.DayOfYear: rename_func("DAYOFYEAR"),
 912            exp.Explode: rename_func("FLATTEN"),
 913            exp.Extract: rename_func("DATE_PART"),
 914            exp.FromTimeZone: lambda self, e: self.func(
 915                "CONVERT_TIMEZONE", e.args.get("zone"), "'UTC'", e.this
 916            ),
 917            exp.GenerateSeries: lambda self, e: self.func(
 918                "ARRAY_GENERATE_RANGE", e.args["start"], e.args["end"] + 1, e.args.get("step")
 919            ),
 920            exp.GroupConcat: rename_func("LISTAGG"),
 921            exp.If: if_sql(name="IFF", false_value="NULL"),
 922            exp.JSONExtractArray: _json_extract_value_array_sql,
 923            exp.JSONExtractScalar: lambda self, e: self.func(
 924                "JSON_EXTRACT_PATH_TEXT", e.this, e.expression
 925            ),
 926            exp.JSONObject: lambda self, e: self.func("OBJECT_CONSTRUCT_KEEP_NULL", *e.expressions),
 927            exp.JSONPathRoot: lambda *_: "",
 928            exp.JSONValueArray: _json_extract_value_array_sql,
 929            exp.LogicalAnd: rename_func("BOOLAND_AGG"),
 930            exp.LogicalOr: rename_func("BOOLOR_AGG"),
 931            exp.Map: lambda self, e: var_map_sql(self, e, "OBJECT_CONSTRUCT"),
 932            exp.MakeInterval: no_make_interval_sql,
 933            exp.Max: max_or_greatest,
 934            exp.Min: min_or_least,
 935            exp.ParseJSON: lambda self, e: self.func(
 936                "TRY_PARSE_JSON" if e.args.get("safe") else "PARSE_JSON", e.this
 937            ),
 938            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
 939            exp.PercentileCont: transforms.preprocess(
 940                [transforms.add_within_group_for_percentiles]
 941            ),
 942            exp.PercentileDisc: transforms.preprocess(
 943                [transforms.add_within_group_for_percentiles]
 944            ),
 945            exp.Pivot: transforms.preprocess([_unqualify_unpivot_columns]),
 946            exp.RegexpExtract: _regexpextract_sql,
 947            exp.RegexpExtractAll: _regexpextract_sql,
 948            exp.RegexpILike: _regexpilike_sql,
 949            exp.Rand: rename_func("RANDOM"),
 950            exp.Select: transforms.preprocess(
 951                [
 952                    transforms.eliminate_distinct_on,
 953                    transforms.explode_to_unnest(),
 954                    transforms.eliminate_semi_and_anti_joins,
 955                    _transform_generate_date_array,
 956                ]
 957            ),
 958            exp.SafeDivide: lambda self, e: no_safe_divide_sql(self, e, "IFF"),
 959            exp.SHA: rename_func("SHA1"),
 960            exp.StarMap: rename_func("OBJECT_CONSTRUCT"),
 961            exp.StartsWith: rename_func("STARTSWITH"),
 962            exp.StrPosition: lambda self, e: self.func(
 963                "POSITION", e.args.get("substr"), e.this, e.args.get("position")
 964            ),
 965            exp.StrToDate: lambda self, e: self.func("DATE", e.this, self.format_time(e)),
 966            exp.Stuff: rename_func("INSERT"),
 967            exp.TimeAdd: date_delta_sql("TIMEADD"),
 968            exp.Timestamp: no_timestamp_sql,
 969            exp.TimestampAdd: date_delta_sql("TIMESTAMPADD"),
 970            exp.TimestampDiff: lambda self, e: self.func(
 971                "TIMESTAMPDIFF", e.unit, e.expression, e.this
 972            ),
 973            exp.TimestampTrunc: timestamptrunc_sql(),
 974            exp.TimeStrToTime: timestrtotime_sql,
 975            exp.TimeToUnix: lambda self, e: f"EXTRACT(epoch_second FROM {self.sql(e, 'this')})",
 976            exp.ToArray: rename_func("TO_ARRAY"),
 977            exp.ToChar: lambda self, e: self.function_fallback_sql(e),
 978            exp.ToDouble: rename_func("TO_DOUBLE"),
 979            exp.TsOrDsAdd: date_delta_sql("DATEADD", cast=True),
 980            exp.TsOrDsDiff: date_delta_sql("DATEDIFF"),
 981            exp.TsOrDsToDate: lambda self, e: self.func(
 982                "TRY_TO_DATE" if e.args.get("safe") else "TO_DATE", e.this, self.format_time(e)
 983            ),
 984            exp.UnixToTime: rename_func("TO_TIMESTAMP"),
 985            exp.Uuid: rename_func("UUID_STRING"),
 986            exp.VarMap: lambda self, e: var_map_sql(self, e, "OBJECT_CONSTRUCT"),
 987            exp.WeekOfYear: rename_func("WEEKOFYEAR"),
 988            exp.Xor: rename_func("BOOLXOR"),
 989            exp.Levenshtein: unsupported_args("ins_cost", "del_cost", "sub_cost")(
 990                rename_func("EDITDISTANCE")
 991            ),
 992        }
 993
 994        SUPPORTED_JSON_PATH_PARTS = {
 995            exp.JSONPathKey,
 996            exp.JSONPathRoot,
 997            exp.JSONPathSubscript,
 998        }
 999
1000        TYPE_MAPPING = {
1001            **generator.Generator.TYPE_MAPPING,
1002            exp.DataType.Type.NESTED: "OBJECT",
1003            exp.DataType.Type.STRUCT: "OBJECT",
1004        }
1005
1006        PROPERTIES_LOCATION = {
1007            **generator.Generator.PROPERTIES_LOCATION,
1008            exp.SetProperty: exp.Properties.Location.UNSUPPORTED,
1009            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
1010        }
1011
1012        UNSUPPORTED_VALUES_EXPRESSIONS = {
1013            exp.Map,
1014            exp.StarMap,
1015            exp.Struct,
1016            exp.VarMap,
1017        }
1018
1019        def with_properties(self, properties: exp.Properties) -> str:
1020            return self.properties(properties, wrapped=False, prefix=self.sep(""), sep=" ")
1021
1022        def values_sql(self, expression: exp.Values, values_as_table: bool = True) -> str:
1023            if expression.find(*self.UNSUPPORTED_VALUES_EXPRESSIONS):
1024                values_as_table = False
1025
1026            return super().values_sql(expression, values_as_table=values_as_table)
1027
1028        def datatype_sql(self, expression: exp.DataType) -> str:
1029            expressions = expression.expressions
1030            if (
1031                expressions
1032                and expression.is_type(*exp.DataType.STRUCT_TYPES)
1033                and any(isinstance(field_type, exp.DataType) for field_type in expressions)
1034            ):
1035                # The correct syntax is OBJECT [ (<key> <value_type [NOT NULL] [, ...]) ]
1036                return "OBJECT"
1037
1038            return super().datatype_sql(expression)
1039
1040        def tonumber_sql(self, expression: exp.ToNumber) -> str:
1041            return self.func(
1042                "TO_NUMBER",
1043                expression.this,
1044                expression.args.get("format"),
1045                expression.args.get("precision"),
1046                expression.args.get("scale"),
1047            )
1048
1049        def timestampfromparts_sql(self, expression: exp.TimestampFromParts) -> str:
1050            milli = expression.args.get("milli")
1051            if milli is not None:
1052                milli_to_nano = milli.pop() * exp.Literal.number(1000000)
1053                expression.set("nano", milli_to_nano)
1054
1055            return rename_func("TIMESTAMP_FROM_PARTS")(self, expression)
1056
1057        def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
1058            if expression.is_type(exp.DataType.Type.GEOGRAPHY):
1059                return self.func("TO_GEOGRAPHY", expression.this)
1060            if expression.is_type(exp.DataType.Type.GEOMETRY):
1061                return self.func("TO_GEOMETRY", expression.this)
1062
1063            return super().cast_sql(expression, safe_prefix=safe_prefix)
1064
1065        def trycast_sql(self, expression: exp.TryCast) -> str:
1066            value = expression.this
1067
1068            if value.type is None:
1069                from sqlglot.optimizer.annotate_types import annotate_types
1070
1071                value = annotate_types(value)
1072
1073            if value.is_type(*exp.DataType.TEXT_TYPES, exp.DataType.Type.UNKNOWN):
1074                return super().trycast_sql(expression)
1075
1076            # TRY_CAST only works for string values in Snowflake
1077            return self.cast_sql(expression)
1078
1079        def log_sql(self, expression: exp.Log) -> str:
1080            if not expression.expression:
1081                return self.func("LN", expression.this)
1082
1083            return super().log_sql(expression)
1084
1085        def unnest_sql(self, expression: exp.Unnest) -> str:
1086            unnest_alias = expression.args.get("alias")
1087            offset = expression.args.get("offset")
1088
1089            columns = [
1090                exp.to_identifier("seq"),
1091                exp.to_identifier("key"),
1092                exp.to_identifier("path"),
1093                offset.pop() if isinstance(offset, exp.Expression) else exp.to_identifier("index"),
1094                seq_get(unnest_alias.columns if unnest_alias else [], 0)
1095                or exp.to_identifier("value"),
1096                exp.to_identifier("this"),
1097            ]
1098
1099            if unnest_alias:
1100                unnest_alias.set("columns", columns)
1101            else:
1102                unnest_alias = exp.TableAlias(this="_u", columns=columns)
1103
1104            table_input = self.sql(expression.expressions[0])
1105            if not table_input.startswith("INPUT =>"):
1106                table_input = f"INPUT => {table_input}"
1107
1108            explode = f"TABLE(FLATTEN({table_input}))"
1109            alias = self.sql(unnest_alias)
1110            alias = f" AS {alias}" if alias else ""
1111            return f"{explode}{alias}"
1112
1113        def show_sql(self, expression: exp.Show) -> str:
1114            terse = "TERSE " if expression.args.get("terse") else ""
1115            history = " HISTORY" if expression.args.get("history") else ""
1116            like = self.sql(expression, "like")
1117            like = f" LIKE {like}" if like else ""
1118
1119            scope = self.sql(expression, "scope")
1120            scope = f" {scope}" if scope else ""
1121
1122            scope_kind = self.sql(expression, "scope_kind")
1123            if scope_kind:
1124                scope_kind = f" IN {scope_kind}"
1125
1126            starts_with = self.sql(expression, "starts_with")
1127            if starts_with:
1128                starts_with = f" STARTS WITH {starts_with}"
1129
1130            limit = self.sql(expression, "limit")
1131
1132            from_ = self.sql(expression, "from")
1133            if from_:
1134                from_ = f" FROM {from_}"
1135
1136            return f"SHOW {terse}{expression.name}{history}{like}{scope_kind}{scope}{starts_with}{limit}{from_}"
1137
1138        def describe_sql(self, expression: exp.Describe) -> str:
1139            # Default to table if kind is unknown
1140            kind_value = expression.args.get("kind") or "TABLE"
1141            kind = f" {kind_value}" if kind_value else ""
1142            this = f" {self.sql(expression, 'this')}"
1143            expressions = self.expressions(expression, flat=True)
1144            expressions = f" {expressions}" if expressions else ""
1145            return f"DESCRIBE{kind}{this}{expressions}"
1146
1147        def generatedasidentitycolumnconstraint_sql(
1148            self, expression: exp.GeneratedAsIdentityColumnConstraint
1149        ) -> str:
1150            start = expression.args.get("start")
1151            start = f" START {start}" if start else ""
1152            increment = expression.args.get("increment")
1153            increment = f" INCREMENT {increment}" if increment else ""
1154            return f"AUTOINCREMENT{start}{increment}"
1155
1156        def cluster_sql(self, expression: exp.Cluster) -> str:
1157            return f"CLUSTER BY ({self.expressions(expression, flat=True)})"
1158
1159        def struct_sql(self, expression: exp.Struct) -> str:
1160            keys = []
1161            values = []
1162
1163            for i, e in enumerate(expression.expressions):
1164                if isinstance(e, exp.PropertyEQ):
1165                    keys.append(
1166                        exp.Literal.string(e.name) if isinstance(e.this, exp.Identifier) else e.this
1167                    )
1168                    values.append(e.expression)
1169                else:
1170                    keys.append(exp.Literal.string(f"_{i}"))
1171                    values.append(e)
1172
1173            return self.func("OBJECT_CONSTRUCT", *flatten(zip(keys, values)))
1174
1175        @unsupported_args("weight", "accuracy")
1176        def approxquantile_sql(self, expression: exp.ApproxQuantile) -> str:
1177            return self.func("APPROX_PERCENTILE", expression.this, expression.args.get("quantile"))
1178
1179        def alterset_sql(self, expression: exp.AlterSet) -> str:
1180            exprs = self.expressions(expression, flat=True)
1181            exprs = f" {exprs}" if exprs else ""
1182            file_format = self.expressions(expression, key="file_format", flat=True, sep=" ")
1183            file_format = f" STAGE_FILE_FORMAT = ({file_format})" if file_format else ""
1184            copy_options = self.expressions(expression, key="copy_options", flat=True, sep=" ")
1185            copy_options = f" STAGE_COPY_OPTIONS = ({copy_options})" if copy_options else ""
1186            tag = self.expressions(expression, key="tag", flat=True)
1187            tag = f" TAG {tag}" if tag else ""
1188
1189            return f"SET{exprs}{file_format}{copy_options}{tag}"
1190
1191        def strtotime_sql(self, expression: exp.StrToTime):
1192            safe_prefix = "TRY_" if expression.args.get("safe") else ""
1193            return self.func(
1194                f"{safe_prefix}TO_TIMESTAMP", expression.this, self.format_time(expression)
1195            )
1196
1197        def timestampsub_sql(self, expression: exp.TimestampSub):
1198            return self.sql(
1199                exp.TimestampAdd(
1200                    this=expression.this,
1201                    expression=expression.expression * -1,
1202                    unit=expression.unit,
1203                )
1204            )
1205
1206        def jsonextract_sql(self, expression: exp.JSONExtract):
1207            this = expression.this
1208
1209            # JSON strings are valid coming from other dialects such as BQ
1210            return self.func(
1211                "GET_PATH",
1212                exp.ParseJSON(this=this) if this.is_string else this,
1213                expression.expression,
1214            )
1215
1216        def timetostr_sql(self, expression: exp.TimeToStr) -> str:
1217            this = expression.this
1218            if not isinstance(this, exp.TsOrDsToTimestamp):
1219                this = exp.cast(this, exp.DataType.Type.TIMESTAMP)
1220
1221            return self.func("TO_CHAR", this, self.format_time(expression))
1222
1223        def datesub_sql(self, expression: exp.DateSub) -> str:
1224            value = expression.expression
1225            if value:
1226                value.replace(value * (-1))
1227            else:
1228                self.unsupported("DateSub cannot be transpiled if the subtracted count is unknown")
1229
1230            return date_delta_sql("DATEADD")(self, expression)
1231
1232        def select_sql(self, expression: exp.Select) -> str:
1233            limit = expression.args.get("limit")
1234            offset = expression.args.get("offset")
1235            if offset and not limit:
1236                expression.limit(exp.Null(), copy=False)
1237            return super().select_sql(expression)