sqlglot.dialects.snowflake

   1from __future__ import annotations
   2
   3import typing as t
   4
   5from sqlglot import exp, generator, parser, tokens, transforms
   6from sqlglot.dialects.dialect import (
   7    Dialect,
   8    NormalizationStrategy,
   9    binary_from_function,
  10    date_delta_sql,
  11    date_trunc_to_time,
  12    datestrtodate_sql,
  13    build_formatted_time,
  14    if_sql,
  15    inline_array_sql,
  16    max_or_greatest,
  17    min_or_least,
  18    rename_func,
  19    timestamptrunc_sql,
  20    timestrtotime_sql,
  21    var_map_sql,
  22)
  23from sqlglot.helper import flatten, is_float, is_int, seq_get
  24from sqlglot.tokens import TokenType
  25
  26if t.TYPE_CHECKING:
  27    from sqlglot._typing import E
  28
  29
  30# from https://docs.snowflake.com/en/sql-reference/functions/to_timestamp.html
  31def _build_datetime(
  32    name: str, kind: exp.DataType.Type, safe: bool = False
  33) -> t.Callable[[t.List], exp.Func]:
  34    def _builder(args: t.List) -> exp.Func:
  35        value = seq_get(args, 0)
  36        int_value = value is not None and is_int(value.name)
  37
  38        if isinstance(value, exp.Literal):
  39            # Converts calls like `TO_TIME('01:02:03')` into casts
  40            if len(args) == 1 and value.is_string and not int_value:
  41                return exp.cast(value, kind)
  42
  43            # Handles `TO_TIMESTAMP(str, fmt)` and `TO_TIMESTAMP(num, scale)` as special
  44            # cases so we can transpile them, since they're relatively common
  45            if kind == exp.DataType.Type.TIMESTAMP:
  46                if int_value:
  47                    return exp.UnixToTime(this=value, scale=seq_get(args, 1))
  48                if not is_float(value.this):
  49                    return build_formatted_time(exp.StrToTime, "snowflake")(args)
  50
  51        if kind == exp.DataType.Type.DATE and not int_value:
  52            formatted_exp = build_formatted_time(exp.TsOrDsToDate, "snowflake")(args)
  53            formatted_exp.set("safe", safe)
  54            return formatted_exp
  55
  56        return exp.Anonymous(this=name, expressions=args)
  57
  58    return _builder
  59
  60
  61def _build_object_construct(args: t.List) -> t.Union[exp.StarMap, exp.Struct]:
  62    expression = parser.build_var_map(args)
  63
  64    if isinstance(expression, exp.StarMap):
  65        return expression
  66
  67    return exp.Struct(
  68        expressions=[
  69            exp.PropertyEQ(this=k, expression=v) for k, v in zip(expression.keys, expression.values)
  70        ]
  71    )
  72
  73
  74def _build_datediff(args: t.List) -> exp.DateDiff:
  75    return exp.DateDiff(
  76        this=seq_get(args, 2), expression=seq_get(args, 1), unit=_map_date_part(seq_get(args, 0))
  77    )
  78
  79
  80def _build_date_time_add(expr_type: t.Type[E]) -> t.Callable[[t.List], E]:
  81    def _builder(args: t.List) -> E:
  82        return expr_type(
  83            this=seq_get(args, 2),
  84            expression=seq_get(args, 1),
  85            unit=_map_date_part(seq_get(args, 0)),
  86        )
  87
  88    return _builder
  89
  90
  91# https://docs.snowflake.com/en/sql-reference/functions/div0
  92def _build_if_from_div0(args: t.List) -> exp.If:
  93    cond = exp.EQ(this=seq_get(args, 1), expression=exp.Literal.number(0))
  94    true = exp.Literal.number(0)
  95    false = exp.Div(this=seq_get(args, 0), expression=seq_get(args, 1))
  96    return exp.If(this=cond, true=true, false=false)
  97
  98
  99# https://docs.snowflake.com/en/sql-reference/functions/zeroifnull
 100def _build_if_from_zeroifnull(args: t.List) -> exp.If:
 101    cond = exp.Is(this=seq_get(args, 0), expression=exp.Null())
 102    return exp.If(this=cond, true=exp.Literal.number(0), false=seq_get(args, 0))
 103
 104
 105# https://docs.snowflake.com/en/sql-reference/functions/zeroifnull
 106def _build_if_from_nullifzero(args: t.List) -> exp.If:
 107    cond = exp.EQ(this=seq_get(args, 0), expression=exp.Literal.number(0))
 108    return exp.If(this=cond, true=exp.Null(), false=seq_get(args, 0))
 109
 110
 111def _regexpilike_sql(self: Snowflake.Generator, expression: exp.RegexpILike) -> str:
 112    flag = expression.text("flag")
 113
 114    if "i" not in flag:
 115        flag += "i"
 116
 117    return self.func(
 118        "REGEXP_LIKE", expression.this, expression.expression, exp.Literal.string(flag)
 119    )
 120
 121
 122def _build_convert_timezone(args: t.List) -> t.Union[exp.Anonymous, exp.AtTimeZone]:
 123    if len(args) == 3:
 124        return exp.Anonymous(this="CONVERT_TIMEZONE", expressions=args)
 125    return exp.AtTimeZone(this=seq_get(args, 1), zone=seq_get(args, 0))
 126
 127
 128def _build_regexp_replace(args: t.List) -> exp.RegexpReplace:
 129    regexp_replace = exp.RegexpReplace.from_arg_list(args)
 130
 131    if not regexp_replace.args.get("replacement"):
 132        regexp_replace.set("replacement", exp.Literal.string(""))
 133
 134    return regexp_replace
 135
 136
 137def _show_parser(*args: t.Any, **kwargs: t.Any) -> t.Callable[[Snowflake.Parser], exp.Show]:
 138    def _parse(self: Snowflake.Parser) -> exp.Show:
 139        return self._parse_show_snowflake(*args, **kwargs)
 140
 141    return _parse
 142
 143
 144DATE_PART_MAPPING = {
 145    "Y": "YEAR",
 146    "YY": "YEAR",
 147    "YYY": "YEAR",
 148    "YYYY": "YEAR",
 149    "YR": "YEAR",
 150    "YEARS": "YEAR",
 151    "YRS": "YEAR",
 152    "MM": "MONTH",
 153    "MON": "MONTH",
 154    "MONS": "MONTH",
 155    "MONTHS": "MONTH",
 156    "D": "DAY",
 157    "DD": "DAY",
 158    "DAYS": "DAY",
 159    "DAYOFMONTH": "DAY",
 160    "WEEKDAY": "DAYOFWEEK",
 161    "DOW": "DAYOFWEEK",
 162    "DW": "DAYOFWEEK",
 163    "WEEKDAY_ISO": "DAYOFWEEKISO",
 164    "DOW_ISO": "DAYOFWEEKISO",
 165    "DW_ISO": "DAYOFWEEKISO",
 166    "YEARDAY": "DAYOFYEAR",
 167    "DOY": "DAYOFYEAR",
 168    "DY": "DAYOFYEAR",
 169    "W": "WEEK",
 170    "WK": "WEEK",
 171    "WEEKOFYEAR": "WEEK",
 172    "WOY": "WEEK",
 173    "WY": "WEEK",
 174    "WEEK_ISO": "WEEKISO",
 175    "WEEKOFYEARISO": "WEEKISO",
 176    "WEEKOFYEAR_ISO": "WEEKISO",
 177    "Q": "QUARTER",
 178    "QTR": "QUARTER",
 179    "QTRS": "QUARTER",
 180    "QUARTERS": "QUARTER",
 181    "H": "HOUR",
 182    "HH": "HOUR",
 183    "HR": "HOUR",
 184    "HOURS": "HOUR",
 185    "HRS": "HOUR",
 186    "M": "MINUTE",
 187    "MI": "MINUTE",
 188    "MIN": "MINUTE",
 189    "MINUTES": "MINUTE",
 190    "MINS": "MINUTE",
 191    "S": "SECOND",
 192    "SEC": "SECOND",
 193    "SECONDS": "SECOND",
 194    "SECS": "SECOND",
 195    "MS": "MILLISECOND",
 196    "MSEC": "MILLISECOND",
 197    "MILLISECONDS": "MILLISECOND",
 198    "US": "MICROSECOND",
 199    "USEC": "MICROSECOND",
 200    "MICROSECONDS": "MICROSECOND",
 201    "NS": "NANOSECOND",
 202    "NSEC": "NANOSECOND",
 203    "NANOSEC": "NANOSECOND",
 204    "NSECOND": "NANOSECOND",
 205    "NSECONDS": "NANOSECOND",
 206    "NANOSECS": "NANOSECOND",
 207    "EPOCH": "EPOCH_SECOND",
 208    "EPOCH_SECONDS": "EPOCH_SECOND",
 209    "EPOCH_MILLISECONDS": "EPOCH_MILLISECOND",
 210    "EPOCH_MICROSECONDS": "EPOCH_MICROSECOND",
 211    "EPOCH_NANOSECONDS": "EPOCH_NANOSECOND",
 212    "TZH": "TIMEZONE_HOUR",
 213    "TZM": "TIMEZONE_MINUTE",
 214}
 215
 216
 217@t.overload
 218def _map_date_part(part: exp.Expression) -> exp.Var:
 219    pass
 220
 221
 222@t.overload
 223def _map_date_part(part: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
 224    pass
 225
 226
 227def _map_date_part(part):
 228    mapped = DATE_PART_MAPPING.get(part.name.upper()) if part else None
 229    return exp.var(mapped) if mapped else part
 230
 231
 232def _date_trunc_to_time(args: t.List) -> exp.DateTrunc | exp.TimestampTrunc:
 233    trunc = date_trunc_to_time(args)
 234    trunc.set("unit", _map_date_part(trunc.args["unit"]))
 235    return trunc
 236
 237
 238def _build_timestamp_from_parts(args: t.List) -> exp.Func:
 239    if len(args) == 2:
 240        # Other dialects don't have the TIMESTAMP_FROM_PARTS(date, time) concept,
 241        # so we parse this into Anonymous for now instead of introducing complexity
 242        return exp.Anonymous(this="TIMESTAMP_FROM_PARTS", expressions=args)
 243
 244    return exp.TimestampFromParts.from_arg_list(args)
 245
 246
 247def _unqualify_unpivot_columns(expression: exp.Expression) -> exp.Expression:
 248    """
 249    Snowflake doesn't allow columns referenced in UNPIVOT to be qualified,
 250    so we need to unqualify them.
 251
 252    Example:
 253        >>> from sqlglot import parse_one
 254        >>> expr = parse_one("SELECT * FROM m_sales UNPIVOT(sales FOR month IN (m_sales.jan, feb, mar, april))")
 255        >>> print(_unqualify_unpivot_columns(expr).sql(dialect="snowflake"))
 256        SELECT * FROM m_sales UNPIVOT(sales FOR month IN (jan, feb, mar, april))
 257    """
 258    if isinstance(expression, exp.Pivot) and expression.unpivot:
 259        expression = transforms.unqualify_columns(expression)
 260
 261    return expression
 262
 263
 264def _flatten_structured_types_unless_iceberg(expression: exp.Expression) -> exp.Expression:
 265    assert isinstance(expression, exp.Create)
 266
 267    def _flatten_structured_type(expression: exp.DataType) -> exp.DataType:
 268        if expression.this in exp.DataType.NESTED_TYPES:
 269            expression.set("expressions", None)
 270        return expression
 271
 272    props = expression.args.get("properties")
 273    if isinstance(expression.this, exp.Schema) and not (props and props.find(exp.IcebergProperty)):
 274        for schema_expression in expression.this.expressions:
 275            if isinstance(schema_expression, exp.ColumnDef):
 276                column_type = schema_expression.kind
 277                if isinstance(column_type, exp.DataType):
 278                    column_type.transform(_flatten_structured_type, copy=False)
 279
 280    return expression
 281
 282
 283class Snowflake(Dialect):
 284    # https://docs.snowflake.com/en/sql-reference/identifiers-syntax
 285    NORMALIZATION_STRATEGY = NormalizationStrategy.UPPERCASE
 286    NULL_ORDERING = "nulls_are_large"
 287    TIME_FORMAT = "'YYYY-MM-DD HH24:MI:SS'"
 288    SUPPORTS_USER_DEFINED_TYPES = False
 289    SUPPORTS_SEMI_ANTI_JOIN = False
 290    PREFER_CTE_ALIAS_COLUMN = True
 291    TABLESAMPLE_SIZE_IS_PERCENT = True
 292    COPY_PARAMS_ARE_CSV = False
 293
 294    TIME_MAPPING = {
 295        "YYYY": "%Y",
 296        "yyyy": "%Y",
 297        "YY": "%y",
 298        "yy": "%y",
 299        "MMMM": "%B",
 300        "mmmm": "%B",
 301        "MON": "%b",
 302        "mon": "%b",
 303        "MM": "%m",
 304        "mm": "%m",
 305        "DD": "%d",
 306        "dd": "%-d",
 307        "DY": "%a",
 308        "dy": "%w",
 309        "HH24": "%H",
 310        "hh24": "%H",
 311        "HH12": "%I",
 312        "hh12": "%I",
 313        "MI": "%M",
 314        "mi": "%M",
 315        "SS": "%S",
 316        "ss": "%S",
 317        "FF": "%f",
 318        "ff": "%f",
 319        "FF6": "%f",
 320        "ff6": "%f",
 321    }
 322
 323    def quote_identifier(self, expression: E, identify: bool = True) -> E:
 324        # This disables quoting DUAL in SELECT ... FROM DUAL, because Snowflake treats an
 325        # unquoted DUAL keyword in a special way and does not map it to a user-defined table
 326        if (
 327            isinstance(expression, exp.Identifier)
 328            and isinstance(expression.parent, exp.Table)
 329            and expression.name.lower() == "dual"
 330        ):
 331            return expression  # type: ignore
 332
 333        return super().quote_identifier(expression, identify=identify)
 334
 335    class Parser(parser.Parser):
 336        IDENTIFY_PIVOT_STRINGS = True
 337
 338        ID_VAR_TOKENS = {
 339            *parser.Parser.ID_VAR_TOKENS,
 340            TokenType.MATCH_CONDITION,
 341        }
 342
 343        TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS | {TokenType.WINDOW}
 344        TABLE_ALIAS_TOKENS.discard(TokenType.MATCH_CONDITION)
 345
 346        FUNCTIONS = {
 347            **parser.Parser.FUNCTIONS,
 348            "ARRAYAGG": exp.ArrayAgg.from_arg_list,
 349            "ARRAY_CONSTRUCT": exp.Array.from_arg_list,
 350            "ARRAY_CONTAINS": lambda args: exp.ArrayContains(
 351                this=seq_get(args, 1), expression=seq_get(args, 0)
 352            ),
 353            "ARRAY_GENERATE_RANGE": lambda args: exp.GenerateSeries(
 354                # ARRAY_GENERATE_RANGE has an exlusive end; we normalize it to be inclusive
 355                start=seq_get(args, 0),
 356                end=exp.Sub(this=seq_get(args, 1), expression=exp.Literal.number(1)),
 357                step=seq_get(args, 2),
 358            ),
 359            "BITXOR": binary_from_function(exp.BitwiseXor),
 360            "BIT_XOR": binary_from_function(exp.BitwiseXor),
 361            "BOOLXOR": binary_from_function(exp.Xor),
 362            "CONVERT_TIMEZONE": _build_convert_timezone,
 363            "DATE": _build_datetime("DATE", exp.DataType.Type.DATE),
 364            "DATE_TRUNC": _date_trunc_to_time,
 365            "DATEADD": _build_date_time_add(exp.DateAdd),
 366            "DATEDIFF": _build_datediff,
 367            "DIV0": _build_if_from_div0,
 368            "FLATTEN": exp.Explode.from_arg_list,
 369            "GET_PATH": lambda args, dialect: exp.JSONExtract(
 370                this=seq_get(args, 0), expression=dialect.to_json_path(seq_get(args, 1))
 371            ),
 372            "IFF": exp.If.from_arg_list,
 373            "LAST_DAY": lambda args: exp.LastDay(
 374                this=seq_get(args, 0), unit=_map_date_part(seq_get(args, 1))
 375            ),
 376            "LISTAGG": exp.GroupConcat.from_arg_list,
 377            "MEDIAN": lambda args: exp.PercentileCont(
 378                this=seq_get(args, 0), expression=exp.Literal.number(0.5)
 379            ),
 380            "NULLIFZERO": _build_if_from_nullifzero,
 381            "OBJECT_CONSTRUCT": _build_object_construct,
 382            "REGEXP_REPLACE": _build_regexp_replace,
 383            "REGEXP_SUBSTR": exp.RegexpExtract.from_arg_list,
 384            "RLIKE": exp.RegexpLike.from_arg_list,
 385            "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)),
 386            "TIMEADD": _build_date_time_add(exp.TimeAdd),
 387            "TIMEDIFF": _build_datediff,
 388            "TIMESTAMPADD": _build_date_time_add(exp.DateAdd),
 389            "TIMESTAMPDIFF": _build_datediff,
 390            "TIMESTAMPFROMPARTS": _build_timestamp_from_parts,
 391            "TIMESTAMP_FROM_PARTS": _build_timestamp_from_parts,
 392            "TRY_TO_DATE": _build_datetime("TRY_TO_DATE", exp.DataType.Type.DATE, safe=True),
 393            "TO_DATE": _build_datetime("TO_DATE", exp.DataType.Type.DATE),
 394            "TO_NUMBER": lambda args: exp.ToNumber(
 395                this=seq_get(args, 0),
 396                format=seq_get(args, 1),
 397                precision=seq_get(args, 2),
 398                scale=seq_get(args, 3),
 399            ),
 400            "TO_TIME": _build_datetime("TO_TIME", exp.DataType.Type.TIME),
 401            "TO_TIMESTAMP": _build_datetime("TO_TIMESTAMP", exp.DataType.Type.TIMESTAMP),
 402            "TO_TIMESTAMP_LTZ": _build_datetime("TO_TIMESTAMP_LTZ", exp.DataType.Type.TIMESTAMPLTZ),
 403            "TO_TIMESTAMP_NTZ": _build_datetime("TO_TIMESTAMP_NTZ", exp.DataType.Type.TIMESTAMP),
 404            "TO_TIMESTAMP_TZ": _build_datetime("TO_TIMESTAMP_TZ", exp.DataType.Type.TIMESTAMPTZ),
 405            "TO_VARCHAR": exp.ToChar.from_arg_list,
 406            "ZEROIFNULL": _build_if_from_zeroifnull,
 407        }
 408
 409        FUNCTION_PARSERS = {
 410            **parser.Parser.FUNCTION_PARSERS,
 411            "DATE_PART": lambda self: self._parse_date_part(),
 412            "OBJECT_CONSTRUCT_KEEP_NULL": lambda self: self._parse_json_object(),
 413        }
 414        FUNCTION_PARSERS.pop("TRIM")
 415
 416        TIMESTAMPS = parser.Parser.TIMESTAMPS - {TokenType.TIME}
 417
 418        RANGE_PARSERS = {
 419            **parser.Parser.RANGE_PARSERS,
 420            TokenType.LIKE_ANY: parser.binary_range_parser(exp.LikeAny),
 421            TokenType.ILIKE_ANY: parser.binary_range_parser(exp.ILikeAny),
 422        }
 423
 424        ALTER_PARSERS = {
 425            **parser.Parser.ALTER_PARSERS,
 426            "SET": lambda self: self._parse_set(tag=self._match_text_seq("TAG")),
 427            "UNSET": lambda self: self.expression(
 428                exp.Set,
 429                tag=self._match_text_seq("TAG"),
 430                expressions=self._parse_csv(self._parse_id_var),
 431                unset=True,
 432            ),
 433            "SWAP": lambda self: self._parse_alter_table_swap(),
 434        }
 435
 436        STATEMENT_PARSERS = {
 437            **parser.Parser.STATEMENT_PARSERS,
 438            TokenType.SHOW: lambda self: self._parse_show(),
 439        }
 440
 441        PROPERTY_PARSERS = {
 442            **parser.Parser.PROPERTY_PARSERS,
 443            "LOCATION": lambda self: self._parse_location(),
 444        }
 445
 446        SHOW_PARSERS = {
 447            "SCHEMAS": _show_parser("SCHEMAS"),
 448            "TERSE SCHEMAS": _show_parser("SCHEMAS"),
 449            "OBJECTS": _show_parser("OBJECTS"),
 450            "TERSE OBJECTS": _show_parser("OBJECTS"),
 451            "TABLES": _show_parser("TABLES"),
 452            "TERSE TABLES": _show_parser("TABLES"),
 453            "VIEWS": _show_parser("VIEWS"),
 454            "TERSE VIEWS": _show_parser("VIEWS"),
 455            "PRIMARY KEYS": _show_parser("PRIMARY KEYS"),
 456            "TERSE PRIMARY KEYS": _show_parser("PRIMARY KEYS"),
 457            "IMPORTED KEYS": _show_parser("IMPORTED KEYS"),
 458            "TERSE IMPORTED KEYS": _show_parser("IMPORTED KEYS"),
 459            "UNIQUE KEYS": _show_parser("UNIQUE KEYS"),
 460            "TERSE UNIQUE KEYS": _show_parser("UNIQUE KEYS"),
 461            "SEQUENCES": _show_parser("SEQUENCES"),
 462            "TERSE SEQUENCES": _show_parser("SEQUENCES"),
 463            "COLUMNS": _show_parser("COLUMNS"),
 464            "USERS": _show_parser("USERS"),
 465            "TERSE USERS": _show_parser("USERS"),
 466        }
 467
 468        STAGED_FILE_SINGLE_TOKENS = {
 469            TokenType.DOT,
 470            TokenType.MOD,
 471            TokenType.SLASH,
 472        }
 473
 474        FLATTEN_COLUMNS = ["SEQ", "KEY", "PATH", "INDEX", "VALUE", "THIS"]
 475
 476        SCHEMA_KINDS = {"OBJECTS", "TABLES", "VIEWS", "SEQUENCES", "UNIQUE KEYS", "IMPORTED KEYS"}
 477
 478        def _parse_column_ops(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
 479            this = super()._parse_column_ops(this)
 480
 481            casts = []
 482            json_path = []
 483
 484            while self._match(TokenType.COLON):
 485                path = super()._parse_column_ops(self._parse_field(any_token=True))
 486
 487                # The cast :: operator has a lower precedence than the extraction operator :, so
 488                # we rearrange the AST appropriately to avoid casting the 2nd argument of GET_PATH
 489                while isinstance(path, exp.Cast):
 490                    casts.append(path.to)
 491                    path = path.this
 492
 493                if path:
 494                    json_path.append(path.sql(dialect="snowflake", copy=False))
 495
 496            if json_path:
 497                this = self.expression(
 498                    exp.JSONExtract,
 499                    this=this,
 500                    expression=self.dialect.to_json_path(exp.Literal.string(".".join(json_path))),
 501                )
 502
 503                while casts:
 504                    this = self.expression(exp.Cast, this=this, to=casts.pop())
 505
 506            return this
 507
 508        # https://docs.snowflake.com/en/sql-reference/functions/date_part.html
 509        # https://docs.snowflake.com/en/sql-reference/functions-date-time.html#label-supported-date-time-parts
 510        def _parse_date_part(self: Snowflake.Parser) -> t.Optional[exp.Expression]:
 511            this = self._parse_var() or self._parse_type()
 512
 513            if not this:
 514                return None
 515
 516            self._match(TokenType.COMMA)
 517            expression = self._parse_bitwise()
 518            this = _map_date_part(this)
 519            name = this.name.upper()
 520
 521            if name.startswith("EPOCH"):
 522                if name == "EPOCH_MILLISECOND":
 523                    scale = 10**3
 524                elif name == "EPOCH_MICROSECOND":
 525                    scale = 10**6
 526                elif name == "EPOCH_NANOSECOND":
 527                    scale = 10**9
 528                else:
 529                    scale = None
 530
 531                ts = self.expression(exp.Cast, this=expression, to=exp.DataType.build("TIMESTAMP"))
 532                to_unix: exp.Expression = self.expression(exp.TimeToUnix, this=ts)
 533
 534                if scale:
 535                    to_unix = exp.Mul(this=to_unix, expression=exp.Literal.number(scale))
 536
 537                return to_unix
 538
 539            return self.expression(exp.Extract, this=this, expression=expression)
 540
 541        def _parse_bracket_key_value(self, is_map: bool = False) -> t.Optional[exp.Expression]:
 542            if is_map:
 543                # Keys are strings in Snowflake's objects, see also:
 544                # - https://docs.snowflake.com/en/sql-reference/data-types-semistructured
 545                # - https://docs.snowflake.com/en/sql-reference/functions/object_construct
 546                return self._parse_slice(self._parse_string())
 547
 548            return self._parse_slice(self._parse_alias(self._parse_conjunction(), explicit=True))
 549
 550        def _parse_lateral(self) -> t.Optional[exp.Lateral]:
 551            lateral = super()._parse_lateral()
 552            if not lateral:
 553                return lateral
 554
 555            if isinstance(lateral.this, exp.Explode):
 556                table_alias = lateral.args.get("alias")
 557                columns = [exp.to_identifier(col) for col in self.FLATTEN_COLUMNS]
 558                if table_alias and not table_alias.args.get("columns"):
 559                    table_alias.set("columns", columns)
 560                elif not table_alias:
 561                    exp.alias_(lateral, "_flattened", table=columns, copy=False)
 562
 563            return lateral
 564
 565        def _parse_at_before(self, table: exp.Table) -> exp.Table:
 566            # https://docs.snowflake.com/en/sql-reference/constructs/at-before
 567            index = self._index
 568            if self._match_texts(("AT", "BEFORE")):
 569                this = self._prev.text.upper()
 570                kind = (
 571                    self._match(TokenType.L_PAREN)
 572                    and self._match_texts(self.HISTORICAL_DATA_KIND)
 573                    and self._prev.text.upper()
 574                )
 575                expression = self._match(TokenType.FARROW) and self._parse_bitwise()
 576
 577                if expression:
 578                    self._match_r_paren()
 579                    when = self.expression(
 580                        exp.HistoricalData, this=this, kind=kind, expression=expression
 581                    )
 582                    table.set("when", when)
 583                else:
 584                    self._retreat(index)
 585
 586            return table
 587
 588        def _parse_table_parts(
 589            self, schema: bool = False, is_db_reference: bool = False, wildcard: bool = False
 590        ) -> exp.Table:
 591            # https://docs.snowflake.com/en/user-guide/querying-stage
 592            if self._match(TokenType.STRING, advance=False):
 593                table = self._parse_string()
 594            elif self._match_text_seq("@", advance=False):
 595                table = self._parse_location_path()
 596            else:
 597                table = None
 598
 599            if table:
 600                file_format = None
 601                pattern = None
 602
 603                self._match(TokenType.L_PAREN)
 604                while self._curr and not self._match(TokenType.R_PAREN):
 605                    if self._match_text_seq("FILE_FORMAT", "=>"):
 606                        file_format = self._parse_string() or super()._parse_table_parts(
 607                            is_db_reference=is_db_reference
 608                        )
 609                    elif self._match_text_seq("PATTERN", "=>"):
 610                        pattern = self._parse_string()
 611                    else:
 612                        break
 613
 614                    self._match(TokenType.COMMA)
 615
 616                table = self.expression(exp.Table, this=table, format=file_format, pattern=pattern)
 617            else:
 618                table = super()._parse_table_parts(schema=schema, is_db_reference=is_db_reference)
 619
 620            return self._parse_at_before(table)
 621
 622        def _parse_id_var(
 623            self,
 624            any_token: bool = True,
 625            tokens: t.Optional[t.Collection[TokenType]] = None,
 626        ) -> t.Optional[exp.Expression]:
 627            if self._match_text_seq("IDENTIFIER", "("):
 628                identifier = (
 629                    super()._parse_id_var(any_token=any_token, tokens=tokens)
 630                    or self._parse_string()
 631                )
 632                self._match_r_paren()
 633                return self.expression(exp.Anonymous, this="IDENTIFIER", expressions=[identifier])
 634
 635            return super()._parse_id_var(any_token=any_token, tokens=tokens)
 636
 637        def _parse_show_snowflake(self, this: str) -> exp.Show:
 638            scope = None
 639            scope_kind = None
 640
 641            # will identity SHOW TERSE SCHEMAS but not SHOW TERSE PRIMARY KEYS
 642            # which is syntactically valid but has no effect on the output
 643            terse = self._tokens[self._index - 2].text.upper() == "TERSE"
 644
 645            history = self._match_text_seq("HISTORY")
 646
 647            like = self._parse_string() if self._match(TokenType.LIKE) else None
 648
 649            if self._match(TokenType.IN):
 650                if self._match_text_seq("ACCOUNT"):
 651                    scope_kind = "ACCOUNT"
 652                elif self._match_set(self.DB_CREATABLES):
 653                    scope_kind = self._prev.text.upper()
 654                    if self._curr:
 655                        scope = self._parse_table_parts()
 656                elif self._curr:
 657                    scope_kind = "SCHEMA" if this in self.SCHEMA_KINDS else "TABLE"
 658                    scope = self._parse_table_parts()
 659
 660            return self.expression(
 661                exp.Show,
 662                **{
 663                    "terse": terse,
 664                    "this": this,
 665                    "history": history,
 666                    "like": like,
 667                    "scope": scope,
 668                    "scope_kind": scope_kind,
 669                    "starts_with": self._match_text_seq("STARTS", "WITH") and self._parse_string(),
 670                    "limit": self._parse_limit(),
 671                    "from": self._parse_string() if self._match(TokenType.FROM) else None,
 672                },
 673            )
 674
 675        def _parse_alter_table_swap(self) -> exp.SwapTable:
 676            self._match_text_seq("WITH")
 677            return self.expression(exp.SwapTable, this=self._parse_table(schema=True))
 678
 679        def _parse_location(self) -> exp.LocationProperty:
 680            self._match(TokenType.EQ)
 681            return self.expression(exp.LocationProperty, this=self._parse_location_path())
 682
 683        def _parse_location_path(self) -> exp.Var:
 684            parts = [self._advance_any(ignore_reserved=True)]
 685
 686            # We avoid consuming a comma token because external tables like @foo and @bar
 687            # can be joined in a query with a comma separator.
 688            while self._is_connected() and not self._match(TokenType.COMMA, advance=False):
 689                parts.append(self._advance_any(ignore_reserved=True))
 690
 691            return exp.var("".join(part.text for part in parts if part))
 692
 693    class Tokenizer(tokens.Tokenizer):
 694        STRING_ESCAPES = ["\\", "'"]
 695        HEX_STRINGS = [("x'", "'"), ("X'", "'")]
 696        RAW_STRINGS = ["$$"]
 697        COMMENTS = ["--", "//", ("/*", "*/")]
 698
 699        KEYWORDS = {
 700            **tokens.Tokenizer.KEYWORDS,
 701            "BYTEINT": TokenType.INT,
 702            "CHAR VARYING": TokenType.VARCHAR,
 703            "CHARACTER VARYING": TokenType.VARCHAR,
 704            "EXCLUDE": TokenType.EXCEPT,
 705            "ILIKE ANY": TokenType.ILIKE_ANY,
 706            "LIKE ANY": TokenType.LIKE_ANY,
 707            "MATCH_CONDITION": TokenType.MATCH_CONDITION,
 708            "MATCH_RECOGNIZE": TokenType.MATCH_RECOGNIZE,
 709            "MINUS": TokenType.EXCEPT,
 710            "NCHAR VARYING": TokenType.VARCHAR,
 711            "PUT": TokenType.COMMAND,
 712            "REMOVE": TokenType.COMMAND,
 713            "RENAME": TokenType.REPLACE,
 714            "RM": TokenType.COMMAND,
 715            "SAMPLE": TokenType.TABLE_SAMPLE,
 716            "SQL_DOUBLE": TokenType.DOUBLE,
 717            "SQL_VARCHAR": TokenType.VARCHAR,
 718            "STORAGE INTEGRATION": TokenType.STORAGE_INTEGRATION,
 719            "TIMESTAMP_TZ": TokenType.TIMESTAMPTZ,
 720            "TOP": TokenType.TOP,
 721        }
 722
 723        SINGLE_TOKENS = {
 724            **tokens.Tokenizer.SINGLE_TOKENS,
 725            "$": TokenType.PARAMETER,
 726        }
 727
 728        VAR_SINGLE_TOKENS = {"$"}
 729
 730        COMMANDS = tokens.Tokenizer.COMMANDS - {TokenType.SHOW}
 731
 732    class Generator(generator.Generator):
 733        PARAMETER_TOKEN = "$"
 734        MATCHED_BY_SOURCE = False
 735        SINGLE_STRING_INTERVAL = True
 736        JOIN_HINTS = False
 737        TABLE_HINTS = False
 738        QUERY_HINTS = False
 739        AGGREGATE_FILTER_SUPPORTED = False
 740        SUPPORTS_TABLE_COPY = False
 741        COLLATE_IS_FUNC = True
 742        LIMIT_ONLY_LITERALS = True
 743        JSON_KEY_VALUE_PAIR_SEP = ","
 744        INSERT_OVERWRITE = " OVERWRITE INTO"
 745        STRUCT_DELIMITER = ("(", ")")
 746        COPY_PARAMS_ARE_WRAPPED = False
 747        COPY_PARAMS_EQ_REQUIRED = True
 748
 749        TRANSFORMS = {
 750            **generator.Generator.TRANSFORMS,
 751            exp.ApproxDistinct: rename_func("APPROX_COUNT_DISTINCT"),
 752            exp.ArgMax: rename_func("MAX_BY"),
 753            exp.ArgMin: rename_func("MIN_BY"),
 754            exp.Array: inline_array_sql,
 755            exp.ArrayConcat: rename_func("ARRAY_CAT"),
 756            exp.ArrayContains: lambda self, e: self.func("ARRAY_CONTAINS", e.expression, e.this),
 757            exp.AtTimeZone: lambda self, e: self.func(
 758                "CONVERT_TIMEZONE", e.args.get("zone"), e.this
 759            ),
 760            exp.BitwiseXor: rename_func("BITXOR"),
 761            exp.Create: transforms.preprocess([_flatten_structured_types_unless_iceberg]),
 762            exp.DateAdd: date_delta_sql("DATEADD"),
 763            exp.DateDiff: date_delta_sql("DATEDIFF"),
 764            exp.DateStrToDate: datestrtodate_sql,
 765            exp.DayOfMonth: rename_func("DAYOFMONTH"),
 766            exp.DayOfWeek: rename_func("DAYOFWEEK"),
 767            exp.DayOfYear: rename_func("DAYOFYEAR"),
 768            exp.Explode: rename_func("FLATTEN"),
 769            exp.Extract: rename_func("DATE_PART"),
 770            exp.FromTimeZone: lambda self, e: self.func(
 771                "CONVERT_TIMEZONE", e.args.get("zone"), "'UTC'", e.this
 772            ),
 773            exp.GenerateSeries: lambda self, e: self.func(
 774                "ARRAY_GENERATE_RANGE", e.args["start"], e.args["end"] + 1, e.args.get("step")
 775            ),
 776            exp.GroupConcat: rename_func("LISTAGG"),
 777            exp.If: if_sql(name="IFF", false_value="NULL"),
 778            exp.JSONExtract: lambda self, e: self.func("GET_PATH", e.this, e.expression),
 779            exp.JSONExtractScalar: lambda self, e: self.func(
 780                "JSON_EXTRACT_PATH_TEXT", e.this, e.expression
 781            ),
 782            exp.JSONObject: lambda self, e: self.func("OBJECT_CONSTRUCT_KEEP_NULL", *e.expressions),
 783            exp.JSONPathRoot: lambda *_: "",
 784            exp.LogicalAnd: rename_func("BOOLAND_AGG"),
 785            exp.LogicalOr: rename_func("BOOLOR_AGG"),
 786            exp.Map: lambda self, e: var_map_sql(self, e, "OBJECT_CONSTRUCT"),
 787            exp.Max: max_or_greatest,
 788            exp.Min: min_or_least,
 789            exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
 790            exp.PercentileCont: transforms.preprocess(
 791                [transforms.add_within_group_for_percentiles]
 792            ),
 793            exp.PercentileDisc: transforms.preprocess(
 794                [transforms.add_within_group_for_percentiles]
 795            ),
 796            exp.Pivot: transforms.preprocess([_unqualify_unpivot_columns]),
 797            exp.RegexpILike: _regexpilike_sql,
 798            exp.Rand: rename_func("RANDOM"),
 799            exp.Select: transforms.preprocess(
 800                [
 801                    transforms.eliminate_distinct_on,
 802                    transforms.explode_to_unnest(),
 803                    transforms.eliminate_semi_and_anti_joins,
 804                ]
 805            ),
 806            exp.SHA: rename_func("SHA1"),
 807            exp.StarMap: rename_func("OBJECT_CONSTRUCT"),
 808            exp.StartsWith: rename_func("STARTSWITH"),
 809            exp.StrPosition: lambda self, e: self.func(
 810                "POSITION", e.args.get("substr"), e.this, e.args.get("position")
 811            ),
 812            exp.StrToTime: lambda self, e: self.func("TO_TIMESTAMP", e.this, self.format_time(e)),
 813            exp.Stuff: rename_func("INSERT"),
 814            exp.TimeAdd: date_delta_sql("TIMEADD"),
 815            exp.TimestampDiff: lambda self, e: self.func(
 816                "TIMESTAMPDIFF", e.unit, e.expression, e.this
 817            ),
 818            exp.TimestampTrunc: timestamptrunc_sql,
 819            exp.TimeStrToTime: timestrtotime_sql,
 820            exp.TimeToStr: lambda self, e: self.func(
 821                "TO_CHAR", exp.cast(e.this, exp.DataType.Type.TIMESTAMP), self.format_time(e)
 822            ),
 823            exp.TimeToUnix: lambda self, e: f"EXTRACT(epoch_second FROM {self.sql(e, 'this')})",
 824            exp.ToArray: rename_func("TO_ARRAY"),
 825            exp.ToChar: lambda self, e: self.function_fallback_sql(e),
 826            exp.Trim: lambda self, e: self.func("TRIM", e.this, e.expression),
 827            exp.TsOrDsAdd: date_delta_sql("DATEADD", cast=True),
 828            exp.TsOrDsDiff: date_delta_sql("DATEDIFF"),
 829            exp.TsOrDsToDate: lambda self, e: self.func(
 830                "TRY_TO_DATE" if e.args.get("safe") else "TO_DATE", e.this, self.format_time(e)
 831            ),
 832            exp.UnixToTime: rename_func("TO_TIMESTAMP"),
 833            exp.VarMap: lambda self, e: var_map_sql(self, e, "OBJECT_CONSTRUCT"),
 834            exp.WeekOfYear: rename_func("WEEKOFYEAR"),
 835            exp.Xor: rename_func("BOOLXOR"),
 836        }
 837
 838        SUPPORTED_JSON_PATH_PARTS = {
 839            exp.JSONPathKey,
 840            exp.JSONPathRoot,
 841            exp.JSONPathSubscript,
 842        }
 843
 844        TYPE_MAPPING = {
 845            **generator.Generator.TYPE_MAPPING,
 846            exp.DataType.Type.NESTED: "OBJECT",
 847            exp.DataType.Type.STRUCT: "OBJECT",
 848        }
 849
 850        STAR_MAPPING = {
 851            "except": "EXCLUDE",
 852            "replace": "RENAME",
 853        }
 854
 855        PROPERTIES_LOCATION = {
 856            **generator.Generator.PROPERTIES_LOCATION,
 857            exp.SetProperty: exp.Properties.Location.UNSUPPORTED,
 858            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
 859        }
 860
 861        UNSUPPORTED_VALUES_EXPRESSIONS = {
 862            exp.Struct,
 863        }
 864
 865        def values_sql(self, expression: exp.Values, values_as_table: bool = True) -> str:
 866            if expression.find(*self.UNSUPPORTED_VALUES_EXPRESSIONS):
 867                values_as_table = False
 868
 869            return super().values_sql(expression, values_as_table=values_as_table)
 870
 871        def datatype_sql(self, expression: exp.DataType) -> str:
 872            expressions = expression.expressions
 873            if (
 874                expressions
 875                and expression.is_type(*exp.DataType.STRUCT_TYPES)
 876                and any(isinstance(field_type, exp.DataType) for field_type in expressions)
 877            ):
 878                # The correct syntax is OBJECT [ (<key> <value_type [NOT NULL] [, ...]) ]
 879                return "OBJECT"
 880
 881            return super().datatype_sql(expression)
 882
 883        def tonumber_sql(self, expression: exp.ToNumber) -> str:
 884            return self.func(
 885                "TO_NUMBER",
 886                expression.this,
 887                expression.args.get("format"),
 888                expression.args.get("precision"),
 889                expression.args.get("scale"),
 890            )
 891
 892        def timestampfromparts_sql(self, expression: exp.TimestampFromParts) -> str:
 893            milli = expression.args.get("milli")
 894            if milli is not None:
 895                milli_to_nano = milli.pop() * exp.Literal.number(1000000)
 896                expression.set("nano", milli_to_nano)
 897
 898            return rename_func("TIMESTAMP_FROM_PARTS")(self, expression)
 899
 900        def trycast_sql(self, expression: exp.TryCast) -> str:
 901            value = expression.this
 902
 903            if value.type is None:
 904                from sqlglot.optimizer.annotate_types import annotate_types
 905
 906                value = annotate_types(value)
 907
 908            if value.is_type(*exp.DataType.TEXT_TYPES, exp.DataType.Type.UNKNOWN):
 909                return super().trycast_sql(expression)
 910
 911            # TRY_CAST only works for string values in Snowflake
 912            return self.cast_sql(expression)
 913
 914        def log_sql(self, expression: exp.Log) -> str:
 915            if not expression.expression:
 916                return self.func("LN", expression.this)
 917
 918            return super().log_sql(expression)
 919
 920        def unnest_sql(self, expression: exp.Unnest) -> str:
 921            unnest_alias = expression.args.get("alias")
 922            offset = expression.args.get("offset")
 923
 924            columns = [
 925                exp.to_identifier("seq"),
 926                exp.to_identifier("key"),
 927                exp.to_identifier("path"),
 928                offset.pop() if isinstance(offset, exp.Expression) else exp.to_identifier("index"),
 929                seq_get(unnest_alias.columns if unnest_alias else [], 0)
 930                or exp.to_identifier("value"),
 931                exp.to_identifier("this"),
 932            ]
 933
 934            if unnest_alias:
 935                unnest_alias.set("columns", columns)
 936            else:
 937                unnest_alias = exp.TableAlias(this="_u", columns=columns)
 938
 939            explode = f"TABLE(FLATTEN(INPUT => {self.sql(expression.expressions[0])}))"
 940            alias = self.sql(unnest_alias)
 941            alias = f" AS {alias}" if alias else ""
 942            return f"{explode}{alias}"
 943
 944        def show_sql(self, expression: exp.Show) -> str:
 945            terse = "TERSE " if expression.args.get("terse") else ""
 946            history = " HISTORY" if expression.args.get("history") else ""
 947            like = self.sql(expression, "like")
 948            like = f" LIKE {like}" if like else ""
 949
 950            scope = self.sql(expression, "scope")
 951            scope = f" {scope}" if scope else ""
 952
 953            scope_kind = self.sql(expression, "scope_kind")
 954            if scope_kind:
 955                scope_kind = f" IN {scope_kind}"
 956
 957            starts_with = self.sql(expression, "starts_with")
 958            if starts_with:
 959                starts_with = f" STARTS WITH {starts_with}"
 960
 961            limit = self.sql(expression, "limit")
 962
 963            from_ = self.sql(expression, "from")
 964            if from_:
 965                from_ = f" FROM {from_}"
 966
 967            return f"SHOW {terse}{expression.name}{history}{like}{scope_kind}{scope}{starts_with}{limit}{from_}"
 968
 969        def regexpextract_sql(self, expression: exp.RegexpExtract) -> str:
 970            # Other dialects don't support all of the following parameters, so we need to
 971            # generate default values as necessary to ensure the transpilation is correct
 972            group = expression.args.get("group")
 973            parameters = expression.args.get("parameters") or (group and exp.Literal.string("c"))
 974            occurrence = expression.args.get("occurrence") or (parameters and exp.Literal.number(1))
 975            position = expression.args.get("position") or (occurrence and exp.Literal.number(1))
 976
 977            return self.func(
 978                "REGEXP_SUBSTR",
 979                expression.this,
 980                expression.expression,
 981                position,
 982                occurrence,
 983                parameters,
 984                group,
 985            )
 986
 987        def except_op(self, expression: exp.Except) -> str:
 988            if not expression.args.get("distinct"):
 989                self.unsupported("EXCEPT with All is not supported in Snowflake")
 990            return super().except_op(expression)
 991
 992        def intersect_op(self, expression: exp.Intersect) -> str:
 993            if not expression.args.get("distinct"):
 994                self.unsupported("INTERSECT with All is not supported in Snowflake")
 995            return super().intersect_op(expression)
 996
 997        def describe_sql(self, expression: exp.Describe) -> str:
 998            # Default to table if kind is unknown
 999            kind_value = expression.args.get("kind") or "TABLE"
1000            kind = f" {kind_value}" if kind_value else ""
1001            this = f" {self.sql(expression, 'this')}"
1002            expressions = self.expressions(expression, flat=True)
1003            expressions = f" {expressions}" if expressions else ""
1004            return f"DESCRIBE{kind}{this}{expressions}"
1005
1006        def generatedasidentitycolumnconstraint_sql(
1007            self, expression: exp.GeneratedAsIdentityColumnConstraint
1008        ) -> str:
1009            start = expression.args.get("start")
1010            start = f" START {start}" if start else ""
1011            increment = expression.args.get("increment")
1012            increment = f" INCREMENT {increment}" if increment else ""
1013            return f"AUTOINCREMENT{start}{increment}"
1014
1015        def swaptable_sql(self, expression: exp.SwapTable) -> str:
1016            this = self.sql(expression, "this")
1017            return f"SWAP WITH {this}"
1018
1019        def with_properties(self, properties: exp.Properties) -> str:
1020            return self.properties(properties, wrapped=False, prefix=self.seg(""), sep=" ")
1021
1022        def cluster_sql(self, expression: exp.Cluster) -> str:
1023            return f"CLUSTER BY ({self.expressions(expression, flat=True)})"
1024
1025        def struct_sql(self, expression: exp.Struct) -> str:
1026            keys = []
1027            values = []
1028
1029            for i, e in enumerate(expression.expressions):
1030                if isinstance(e, exp.PropertyEQ):
1031                    keys.append(
1032                        exp.Literal.string(e.name) if isinstance(e.this, exp.Identifier) else e.this
1033                    )
1034                    values.append(e.expression)
1035                else:
1036                    keys.append(exp.Literal.string(f"_{i}"))
1037                    values.append(e)
1038
1039            return self.func("OBJECT_CONSTRUCT", *flatten(zip(keys, values)))