sqlglot 28.4.1__py3-none-any.whl → 28.8.0__py3-none-any.whl

sqlglot/dialects/snowflake.py

@@ -6,6 +6,8 @@ from sqlglot import exp, generator, jsonpath, parser, tokens, transforms
 from sqlglot.dialects.dialect import (
     Dialect,
     NormalizationStrategy,
+    array_append_sql,
+    array_concat_sql,
     build_timetostr_or_tochar,
     build_like,
     binary_from_function,
@@ -32,7 +34,7 @@ from sqlglot.dialects.dialect import (
     groupconcat_sql,
 )
 from sqlglot.generator import unsupported_args
-from sqlglot.helper import find_new_name, flatten, is_float, is_int, seq_get
+from sqlglot.helper import find_new_name, flatten, is_date_unit, is_int, seq_get
 from sqlglot.optimizer.scope import build_scope, find_all_in_scope
 from sqlglot.tokens import TokenType
 from sqlglot.typing.snowflake import EXPRESSION_METADATA
@@ -41,6 +43,15 @@ if t.TYPE_CHECKING:
     from sqlglot._typing import E, B
 
 
+# Timestamp types used in _build_datetime
+TIMESTAMP_TYPES = {
+    exp.DataType.Type.TIMESTAMP: "TO_TIMESTAMP",
+    exp.DataType.Type.TIMESTAMPLTZ: "TO_TIMESTAMP_LTZ",
+    exp.DataType.Type.TIMESTAMPNTZ: "TO_TIMESTAMP_NTZ",
+    exp.DataType.Type.TIMESTAMPTZ: "TO_TIMESTAMP_TZ",
+}
+
+
 def _build_strtok(args: t.List) -> exp.SplitPart:
     # Add default delimiter (space) if missing - per Snowflake docs
     if len(args) == 1:
@@ -68,6 +79,15 @@ def _build_approx_top_k(args: t.List) -> exp.ApproxTopK:
     return exp.ApproxTopK.from_arg_list(args)
 
 
+def _build_date_from_parts(args: t.List) -> exp.DateFromParts:
+    return exp.DateFromParts(
+        year=seq_get(args, 0),
+        month=seq_get(args, 1),
+        day=seq_get(args, 2),
+        allow_overflow=True,
+    )
+
+
 def _build_datetime(
     name: str, kind: exp.DataType.Type, safe: bool = False
 ) -> t.Callable[[t.List], exp.Func]:
@@ -78,7 +98,7 @@ def _build_datetime(
         int_value = value is not None and is_int(value.name)
         int_scale_or_fmt = scale_or_fmt is not None and scale_or_fmt.is_int
 
-        if isinstance(value, exp.Literal) or (value and scale_or_fmt):
+        if isinstance(value, (exp.Literal, exp.Neg)) or (value and scale_or_fmt):
             # Converts calls like `TO_TIME('01:02:03')` into casts
             if len(args) == 1 and value.is_string and not int_value:
                 return (
@@ -89,17 +109,27 @@ def _build_datetime(
 
             # Handles `TO_TIMESTAMP(str, fmt)` and `TO_TIMESTAMP(num, scale)` as special
             # cases so we can transpile them, since they're relatively common
-            if kind == exp.DataType.Type.TIMESTAMP:
-                if not safe and (int_value or int_scale_or_fmt):
+            if kind in TIMESTAMP_TYPES:
+                if not safe and (int_scale_or_fmt or (int_value and scale_or_fmt is None)):
                     # TRY_TO_TIMESTAMP('integer') is not parsed into exp.UnixToTime as
-                    # it's not easily transpilable
-                    return exp.UnixToTime(this=value, scale=scale_or_fmt)
-                if not int_scale_or_fmt and not is_float(value.name):
-                    expr = build_formatted_time(exp.StrToTime, "snowflake")(args)
-                    expr.set("safe", safe)
-                    return expr
-
-        if kind in (exp.DataType.Type.DATE, exp.DataType.Type.TIME) and not int_value:
+                    # it's not easily transpilable. Also, numeric-looking strings with
+                    # format strings (e.g., TO_TIMESTAMP('20240115', 'YYYYMMDD')) should
+                    # use StrToTime, not UnixToTime.
+                    unix_expr = exp.UnixToTime(this=value, scale=scale_or_fmt)
+                    unix_expr.set("target_type", exp.DataType.build(kind, dialect="snowflake"))
+                    return unix_expr
+                if scale_or_fmt and not int_scale_or_fmt:
+                    # Format string provided (e.g., 'YYYY-MM-DD'), use StrToTime
+                    strtotime_expr = build_formatted_time(exp.StrToTime, "snowflake")(args)
+                    strtotime_expr.set("safe", safe)
+                    strtotime_expr.set("target_type", exp.DataType.build(kind, dialect="snowflake"))
+                    return strtotime_expr
+
+        # Handle DATE/TIME with format strings - allow int_value if a format string is provided
+        has_format_string = scale_or_fmt and not int_scale_or_fmt
+        if kind in (exp.DataType.Type.DATE, exp.DataType.Type.TIME) and (
+            not int_value or has_format_string
+        ):
             klass = exp.TsOrDsToDate if kind == exp.DataType.Type.DATE else exp.TsOrDsToTime
             formatted_exp = build_formatted_time(klass, "snowflake")(args)
             formatted_exp.set("safe", safe)
@@ -125,7 +155,10 @@ def _build_object_construct(args: t.List) -> t.Union[exp.StarMap, exp.Struct]:
 
 def _build_datediff(args: t.List) -> exp.DateDiff:
     return exp.DateDiff(
-        this=seq_get(args, 2), expression=seq_get(args, 1), unit=map_date_part(seq_get(args, 0))
+        this=seq_get(args, 2),
+        expression=seq_get(args, 1),
+        unit=map_date_part(seq_get(args, 0)),
+        date_part_boundary=True,
     )
 
 
@@ -150,7 +183,13 @@ def _build_bitwise(expr_type: t.Type[B], name: str) -> t.Callable[[t.List], B |
                 )
             return exp.Anonymous(this=name, expressions=args)
 
-        return binary_from_function(expr_type)(args)
+        result = binary_from_function(expr_type)(args)
+
+        # Snowflake specifies INT128 for bitwise shifts
+        if expr_type in (exp.BitwiseLeftShift, exp.BitwiseRightShift):
+            result.set("requires_int128", True)
+
+        return result
 
     return _builder
 
@@ -232,7 +271,13 @@ def _show_parser(*args: t.Any, **kwargs: t.Any) -> t.Callable[[Snowflake.Parser]
 
 def _date_trunc_to_time(args: t.List) -> exp.DateTrunc | exp.TimestampTrunc:
     trunc = date_trunc_to_time(args)
-    trunc.set("unit", map_date_part(trunc.args["unit"]))
+    unit = map_date_part(trunc.args["unit"])
+    trunc.set("unit", unit)
+    is_time_input = trunc.this.is_type(exp.DataType.Type.TIME, exp.DataType.Type.TIMETZ)
+    if (isinstance(trunc, exp.TimestampTrunc) and is_date_unit(unit) or is_time_input) or (
+        isinstance(trunc, exp.DateTrunc) and not is_date_unit(unit)
+    ):
+        trunc.set("input_type_preserved", True)
     return trunc
 
 
@@ -595,6 +640,25 @@ def _build_round(args: t.List) -> exp.Round:
     return expression
 
 
+def _build_generator(args: t.List) -> exp.Generator:
+    """
+    Build Generator expression, unwrapping Snowflake's named parameters.
+
+    Maps ROWCOUNT => rowcount, TIMELIMIT => time_limit.
+    """
+    kwarg_map = {"ROWCOUNT": "rowcount", "TIMELIMIT": "time_limit"}
+    gen_args = {}
+
+    for arg in args:
+        if isinstance(arg, exp.Kwarg):
+            key = arg.this.name.upper()
+            gen_key = kwarg_map.get(key)
+            if gen_key:
+                gen_args[gen_key] = arg.expression
+
+    return exp.Generator(**gen_args)
+
+
 def _build_try_to_number(args: t.List[exp.Expression]) -> exp.Expression:
     return exp.ToNumber(
         this=seq_get(args, 0),
@@ -616,15 +680,21 @@ class Snowflake(Dialect):
     TABLESAMPLE_SIZE_IS_PERCENT = True
     COPY_PARAMS_ARE_CSV = False
     ARRAY_AGG_INCLUDES_NULLS = None
+    ARRAY_FUNCS_PROPAGATES_NULLS = True
     ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN = False
     TRY_CAST_REQUIRES_STRING = True
     SUPPORTS_ALIAS_REFS_IN_JOIN_CONDITIONS = True
+    LEAST_GREATEST_IGNORES_NULLS = False
 
     EXPRESSION_METADATA = EXPRESSION_METADATA.copy()
 
     # https://docs.snowflake.com/en/en/sql-reference/functions/initcap
     INITCAP_DEFAULT_DELIMITER_CHARS = ' \t\n\r\f\v!?@"^#$&~_,.:;+\\-*%/|\\[\\](){}<>'
 
+    INVERSE_TIME_MAPPING = {
+        "T": "T",  # in TIME_MAPPING we map '"T"' with the double quotes to 'T', and we want to prevent 'T' from being mapped back to '"T"' so that 'AUTO' doesn't become 'AU"T"O'
+    }
+
     TIME_MAPPING = {
         "YYYY": "%Y",
         "yyyy": "%Y",
@@ -648,13 +718,55 @@ class Snowflake(Dialect):
         "mi": "%M",
         "SS": "%S",
         "ss": "%S",
+        "FF": "%f_nine",  # %f_ internal representation with precision specified
+        "ff": "%f_nine",
+        "FF0": "%f_zero",
+        "ff0": "%f_zero",
+        "FF1": "%f_one",
+        "ff1": "%f_one",
+        "FF2": "%f_two",
+        "ff2": "%f_two",
+        "FF3": "%f_three",
+        "ff3": "%f_three",
+        "FF4": "%f_four",
+        "ff4": "%f_four",
+        "FF5": "%f_five",
+        "ff5": "%f_five",
         "FF6": "%f",
         "ff6": "%f",
+        "FF7": "%f_seven",
+        "ff7": "%f_seven",
+        "FF8": "%f_eight",
+        "ff8": "%f_eight",
+        "FF9": "%f_nine",
+        "ff9": "%f_nine",
+        "TZHTZM": "%z",
+        "tzhtzm": "%z",
+        "TZH:TZM": "%:z",  # internal representation for ±HH:MM
+        "tzh:tzm": "%:z",
+        "TZH": "%-z",  # internal representation ±HH
+        "tzh": "%-z",
+        '"T"': "T",  # remove the optional double quotes around the separator between the date and time
+        # Seems like Snowflake treats AM/PM in the format string as equivalent,
+        # only the time (stamp) value's AM/PM affects the output
+        "AM": "%p",
+        "am": "%p",
+        "PM": "%p",
+        "pm": "%p",
     }
 
     DATE_PART_MAPPING = {
         **Dialect.DATE_PART_MAPPING,
         "ISOWEEK": "WEEKISO",
+        # The base Dialect maps EPOCH_SECOND -> EPOCH, but we need to preserve
+        # EPOCH_SECOND as a distinct value for two reasons:
+        # 1. Type annotation: EPOCH_SECOND returns BIGINT, while EPOCH returns DOUBLE
+        # 2. Transpilation: DuckDB's EPOCH() returns float, so we cast EPOCH_SECOND
+        #    to BIGINT to match Snowflake's integer behavior
+        # Without this override, EXTRACT(EPOCH_SECOND FROM ts) would be normalized
+        # to EXTRACT(EPOCH FROM ts) and lose the integer semantics.
+        "EPOCH_SECOND": "EPOCH_SECOND",
+        "EPOCH_SECONDS": "EPOCH_SECOND",
     }
 
     PSEUDOCOLUMNS = {"LEVEL"}
@@ -689,9 +801,20 @@ class Snowflake(Dialect):
 
         COLON_PLACEHOLDER_TOKENS = ID_VAR_TOKENS | {TokenType.NUMBER}
 
+        NO_PAREN_FUNCTIONS = {
+            **parser.Parser.NO_PAREN_FUNCTIONS,
+            TokenType.CURRENT_TIME: exp.Localtime,
+        }
+
         FUNCTIONS = {
             **parser.Parser.FUNCTIONS,
+            "ADD_MONTHS": lambda args: exp.AddMonths(
+                this=seq_get(args, 0),
+                expression=seq_get(args, 1),
+                preserve_end_of_month=True,
+            ),
             "APPROX_PERCENTILE": exp.ApproxQuantile.from_arg_list,
+            "CURRENT_TIME": lambda args: exp.Localtime(this=seq_get(args, 0)),
             "APPROX_TOP_K": _build_approx_top_k,
             "ARRAY_CONSTRUCT": lambda args: exp.Array(expressions=args),
             "ARRAY_CONTAINS": lambda args: exp.ArrayContains(
@@ -704,6 +827,7 @@ class Snowflake(Dialect):
                 step=seq_get(args, 2),
             ),
             "ARRAY_SORT": exp.SortArray.from_arg_list,
+            "ARRAY_FLATTEN": exp.Flatten.from_arg_list,
             "BITAND": _build_bitwise(exp.BitwiseAnd, "BITAND"),
             "BIT_AND": _build_bitwise(exp.BitwiseAnd, "BITAND"),
             "BITNOT": lambda args: exp.BitwiseNot(this=seq_get(args, 0)),
@@ -729,11 +853,28 @@ class Snowflake(Dialect):
             "BIT_XOR_AGG": exp.BitwiseXorAgg.from_arg_list,
             "BIT_XORAGG": exp.BitwiseXorAgg.from_arg_list,
             "BITMAP_OR_AGG": exp.BitmapOrAgg.from_arg_list,
-            "BOOLXOR": _build_bitwise(exp.Xor, "BOOLXOR"),
+            "BOOLAND": lambda args: exp.Booland(
+                this=seq_get(args, 0), expression=seq_get(args, 1), round_input=True
+            ),
+            "BOOLOR": lambda args: exp.Boolor(
+                this=seq_get(args, 0), expression=seq_get(args, 1), round_input=True
+            ),
+            "BOOLNOT": lambda args: exp.Boolnot(this=seq_get(args, 0), round_input=True),
+            "BOOLXOR": lambda args: exp.Xor(
+                this=seq_get(args, 0), expression=seq_get(args, 1), round_input=True
+            ),
+            "CORR": lambda args: exp.Corr(
+                this=seq_get(args, 0),
+                expression=seq_get(args, 1),
+                null_on_zero_variance=True,
+            ),
             "DATE": _build_datetime("DATE", exp.DataType.Type.DATE),
+            "DATEFROMPARTS": _build_date_from_parts,
+            "DATE_FROM_PARTS": _build_date_from_parts,
             "DATE_TRUNC": _date_trunc_to_time,
             "DATEADD": _build_date_time_add(exp.DateAdd),
             "DATEDIFF": _build_datediff,
+            "DAYNAME": lambda args: exp.Dayname(this=seq_get(args, 0), abbreviated=True),
             "DAYOFWEEKISO": exp.DayOfWeekIso.from_arg_list,
             "DIV0": _build_if_from_div0,
             "DIV0NULL": _build_if_from_div0null,
@@ -741,6 +882,7 @@ class Snowflake(Dialect):
                 this=seq_get(args, 0), expression=seq_get(args, 1), max_dist=seq_get(args, 2)
             ),
             "FLATTEN": exp.Explode.from_arg_list,
+            "GENERATOR": _build_generator,
             "GET": exp.GetExtract.from_arg_list,
             "GETDATE": exp.CurrentTimestamp.from_arg_list,
             "GET_PATH": lambda args, dialect: exp.JSONExtract(
@@ -748,19 +890,28 @@ class Snowflake(Dialect):
                 expression=dialect.to_json_path(seq_get(args, 1)),
                 requires_json=True,
             ),
+            "GREATEST_IGNORE_NULLS": lambda args: exp.Greatest(
+                this=seq_get(args, 0), expressions=args[1:], ignore_nulls=True
+            ),
+            "LEAST_IGNORE_NULLS": lambda args: exp.Least(
+                this=seq_get(args, 0), expressions=args[1:], ignore_nulls=True
+            ),
             "HEX_DECODE_BINARY": exp.Unhex.from_arg_list,
             "IFF": exp.If.from_arg_list,
             "MD5_HEX": exp.MD5.from_arg_list,
             "MD5_BINARY": exp.MD5Digest.from_arg_list,
             "MD5_NUMBER_LOWER64": exp.MD5NumberLower64.from_arg_list,
             "MD5_NUMBER_UPPER64": exp.MD5NumberUpper64.from_arg_list,
+            "MONTHNAME": lambda args: exp.Monthname(this=seq_get(args, 0), abbreviated=True),
             "LAST_DAY": lambda args: exp.LastDay(
                 this=seq_get(args, 0), unit=map_date_part(seq_get(args, 1))
             ),
             "LEN": lambda args: exp.Length(this=seq_get(args, 0), binary=True),
             "LENGTH": lambda args: exp.Length(this=seq_get(args, 0), binary=True),
+            "LOCALTIMESTAMP": exp.CurrentTimestamp.from_arg_list,
             "NULLIFZERO": _build_if_from_nullifzero,
             "OBJECT_CONSTRUCT": _build_object_construct,
+            "OBJECT_KEYS": exp.JSONKeys.from_arg_list,
             "OCTET_LENGTH": exp.ByteLength.from_arg_list,
             "PARSE_URL": lambda args: exp.ParseUrl(
                 this=seq_get(args, 0), permissive=seq_get(args, 1)
@@ -777,16 +928,41 @@ class Snowflake(Dialect):
             "SHA2_BINARY": exp.SHA2Digest.from_arg_list,
             "SHA2_HEX": exp.SHA2.from_arg_list,
             "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)),
+            "STDDEV_SAMP": exp.Stddev.from_arg_list,
             "STRTOK": _build_strtok,
+            "SYSDATE": lambda args: exp.CurrentTimestamp(this=seq_get(args, 0), sysdate=True),
             "TABLE": lambda args: exp.TableFromRows(this=seq_get(args, 0)),
             "TIMEADD": _build_date_time_add(exp.TimeAdd),
             "TIMEDIFF": _build_datediff,
+            "TIME_FROM_PARTS": lambda args: exp.TimeFromParts(
+                hour=seq_get(args, 0),
+                min=seq_get(args, 1),
+                sec=seq_get(args, 2),
+                nano=seq_get(args, 3),
+                overflow=True,
+            ),
             "TIMESTAMPADD": _build_date_time_add(exp.DateAdd),
             "TIMESTAMPDIFF": _build_datediff,
             "TIMESTAMPFROMPARTS": _build_timestamp_from_parts,
             "TIMESTAMP_FROM_PARTS": _build_timestamp_from_parts,
             "TIMESTAMPNTZFROMPARTS": _build_timestamp_from_parts,
             "TIMESTAMP_NTZ_FROM_PARTS": _build_timestamp_from_parts,
+            "TRY_DECRYPT": lambda args: exp.Decrypt(
+                this=seq_get(args, 0),
+                passphrase=seq_get(args, 1),
+                aad=seq_get(args, 2),
+                encryption_method=seq_get(args, 3),
+                safe=True,
+            ),
+            "TRY_DECRYPT_RAW": lambda args: exp.DecryptRaw(
+                this=seq_get(args, 0),
+                key=seq_get(args, 1),
+                iv=seq_get(args, 2),
+                aad=seq_get(args, 3),
+                encryption_method=seq_get(args, 4),
+                aead=seq_get(args, 5),
+                safe=True,
+            ),
             "TRY_PARSE_JSON": lambda args: exp.ParseJSON(this=seq_get(args, 0), safe=True),
             "TRY_TO_BINARY": lambda args: exp.ToBinary(
                 this=seq_get(args, 0), format=seq_get(args, 1), safe=True
@@ -806,6 +982,15 @@ class Snowflake(Dialect):
             "TRY_TO_TIMESTAMP": _build_datetime(
                 "TRY_TO_TIMESTAMP", exp.DataType.Type.TIMESTAMP, safe=True
             ),
+            "TRY_TO_TIMESTAMP_LTZ": _build_datetime(
+                "TRY_TO_TIMESTAMP_LTZ", exp.DataType.Type.TIMESTAMPLTZ, safe=True
+            ),
+            "TRY_TO_TIMESTAMP_NTZ": _build_datetime(
+                "TRY_TO_TIMESTAMP_NTZ", exp.DataType.Type.TIMESTAMPNTZ, safe=True
+            ),
+            "TRY_TO_TIMESTAMP_TZ": _build_datetime(
+                "TRY_TO_TIMESTAMP_TZ", exp.DataType.Type.TIMESTAMPTZ, safe=True
+            ),
             "TO_CHAR": build_timetostr_or_tochar,
             "TO_DATE": _build_datetime("TO_DATE", exp.DataType.Type.DATE),
             **dict.fromkeys(
@@ -820,7 +1005,7 @@ class Snowflake(Dialect):
             "TO_TIME": _build_datetime("TO_TIME", exp.DataType.Type.TIME),
             "TO_TIMESTAMP": _build_datetime("TO_TIMESTAMP", exp.DataType.Type.TIMESTAMP),
             "TO_TIMESTAMP_LTZ": _build_datetime("TO_TIMESTAMP_LTZ", exp.DataType.Type.TIMESTAMPLTZ),
-            "TO_TIMESTAMP_NTZ": _build_datetime("TO_TIMESTAMP_NTZ", exp.DataType.Type.TIMESTAMP),
+            "TO_TIMESTAMP_NTZ": _build_datetime("TO_TIMESTAMP_NTZ", exp.DataType.Type.TIMESTAMPNTZ),
             "TO_TIMESTAMP_TZ": _build_datetime("TO_TIMESTAMP_TZ", exp.DataType.Type.TIMESTAMPTZ),
             "TO_VARCHAR": build_timetostr_or_tochar,
             "TO_JSON": exp.JSONFormat.from_arg_list,
@@ -1045,7 +1230,9 @@ class Snowflake(Dialect):
             expression = (
                 self._match_set((TokenType.FROM, TokenType.COMMA)) and self._parse_bitwise()
             )
-            return self.expression(exp.Extract, this=map_date_part(this), expression=expression)
+            return self.expression(
+                exp.Extract, this=map_date_part(this, self.dialect), expression=expression
+            )
 
         def _parse_bracket_key_value(self, is_map: bool = False) -> t.Optional[exp.Expression]:
             if is_map:
@@ -1387,6 +1574,7 @@ class Snowflake(Dialect):
         ARRAY_SIZE_NAME = "ARRAY_SIZE"
         SUPPORTS_DECODE_CASE = True
         IS_BOOL_ALLOWED = False
+        DIRECTED_JOINS = True
 
         TRANSFORMS = {
             **generator.Generator.TRANSFORMS,
@@ -1394,7 +1582,9 @@ class Snowflake(Dialect):
             exp.ArgMax: rename_func("MAX_BY"),
             exp.ArgMin: rename_func("MIN_BY"),
             exp.Array: transforms.preprocess([transforms.inherit_struct_field_names]),
-            exp.ArrayConcat: lambda self, e: self.arrayconcat_sql(e, name="ARRAY_CAT"),
+            exp.ArrayConcat: array_concat_sql("ARRAY_CAT"),
+            exp.ArrayAppend: array_append_sql("ARRAY_APPEND"),
+            exp.ArrayPrepend: array_append_sql("ARRAY_PREPEND"),
             exp.ArrayContains: lambda self, e: self.func(
                 "ARRAY_CONTAINS",
                 e.expression
@@ -1416,11 +1606,36 @@ class Snowflake(Dialect):
             exp.BitwiseLeftShift: rename_func("BITSHIFTLEFT"),
             exp.BitwiseRightShift: rename_func("BITSHIFTRIGHT"),
             exp.Create: transforms.preprocess([_flatten_structured_types_unless_iceberg]),
+            exp.CurrentTimestamp: lambda self, e: self.func("SYSDATE")
+            if e.args.get("sysdate")
+            else self.function_fallback_sql(e),
+            exp.Localtime: lambda self, e: self.func("CURRENT_TIME", e.this)
+            if e.this
+            else "CURRENT_TIME",
+            exp.Localtimestamp: lambda self, e: self.func("CURRENT_TIMESTAMP", e.this)
+            if e.this
+            else "CURRENT_TIMESTAMP",
             exp.DateAdd: date_delta_sql("DATEADD"),
             exp.DateDiff: date_delta_sql("DATEDIFF"),
             exp.DatetimeAdd: date_delta_sql("TIMESTAMPADD"),
             exp.DatetimeDiff: timestampdiff_sql,
             exp.DateStrToDate: datestrtodate_sql,
+            exp.Decrypt: lambda self, e: self.func(
+                f"{'TRY_' if e.args.get('safe') else ''}DECRYPT",
+                e.this,
+                e.args.get("passphrase"),
+                e.args.get("aad"),
+                e.args.get("encryption_method"),
+            ),
+            exp.DecryptRaw: lambda self, e: self.func(
+                f"{'TRY_' if e.args.get('safe') else ''}DECRYPT_RAW",
+                e.this,
+                e.args.get("key"),
+                e.args.get("iv"),
+                e.args.get("aad"),
+                e.args.get("encryption_method"),
+                e.args.get("aead"),
+            ),
             exp.DayOfMonth: rename_func("DAYOFMONTH"),
             exp.DayOfWeek: rename_func("DAYOFWEEK"),
             exp.DayOfWeekIso: rename_func("DAYOFWEEKISO"),
@@ -1447,6 +1662,7 @@ class Snowflake(Dialect):
             exp.JSONExtractScalar: lambda self, e: self.func(
                 "JSON_EXTRACT_PATH_TEXT", e.this, e.expression
             ),
+            exp.JSONKeys: rename_func("OBJECT_KEYS"),
             exp.JSONObject: lambda self, e: self.func("OBJECT_CONSTRUCT_KEEP_NULL", *e.expressions),
             exp.JSONPathRoot: lambda *_: "",
             exp.JSONValueArray: _json_extract_value_array_sql,
@@ -1552,7 +1768,7 @@ class Snowflake(Dialect):
                 f"{'TRY_' if e.args.get('safe') else ''}TO_TIME", e.this, self.format_time(e)
             ),
             exp.Unhex: rename_func("HEX_DECODE_BINARY"),
-            exp.UnixToTime: rename_func("TO_TIMESTAMP"),
+            exp.UnixToTime: lambda self, e: self.func("TO_TIMESTAMP", e.this, e.args.get("scale")),
             exp.Uuid: rename_func("UUID_STRING"),
             exp.VarMap: lambda self, e: var_map_sql(self, e, "OBJECT_CONSTRUCT"),
             exp.Booland: rename_func("BOOLAND"),
@@ -1562,6 +1778,7 @@ class Snowflake(Dialect):
             exp.YearOfWeekIso: rename_func("YEAROFWEEKISO"),
             exp.Xor: rename_func("BOOLXOR"),
             exp.ByteLength: rename_func("OCTET_LENGTH"),
+            exp.Flatten: rename_func("ARRAY_FLATTEN"),
             exp.ArrayConcatAgg: lambda self, e: self.func(
                 "ARRAY_FLATTEN", exp.ArrayAgg(this=e.this)
             ),
@@ -1693,6 +1910,26 @@ class Snowflake(Dialect):
 
             return super().log_sql(expression)
 
+        def greatest_sql(self, expression: exp.Greatest) -> str:
+            name = "GREATEST_IGNORE_NULLS" if expression.args.get("ignore_nulls") else "GREATEST"
+            return self.func(name, expression.this, *expression.expressions)
+
+        def least_sql(self, expression: exp.Least) -> str:
+            name = "LEAST_IGNORE_NULLS" if expression.args.get("ignore_nulls") else "LEAST"
+            return self.func(name, expression.this, *expression.expressions)
+
+        def generator_sql(self, expression: exp.Generator) -> str:
+            args = []
+            rowcount = expression.args.get("rowcount")
+            time_limit = expression.args.get("time_limit")
+
+            if rowcount:
+                args.append(exp.Kwarg(this=exp.var("ROWCOUNT"), expression=rowcount))
+            if time_limit:
+                args.append(exp.Kwarg(this=exp.var("TIMELIMIT"), expression=time_limit))
+
+            return self.func("GENERATOR", *args)
+
         def unnest_sql(self, expression: exp.Unnest) -> str:
             unnest_alias = expression.args.get("alias")
             offset = expression.args.get("offset")
@@ -1830,8 +2067,21 @@ class Snowflake(Dialect):
             return f"SET{exprs}{file_format}{copy_options}{tag}"
 
         def strtotime_sql(self, expression: exp.StrToTime):
+            # target_type is stored as a DataType instance
+            target_type = expression.args.get("target_type")
+
+            # Get the type enum from DataType instance or from type annotation
+            if isinstance(target_type, exp.DataType):
+                type_enum = target_type.this
+            elif expression.type:
+                type_enum = expression.type.this
+            else:
+                type_enum = exp.DataType.Type.TIMESTAMP
+
+            func_name = TIMESTAMP_TYPES.get(type_enum, "TO_TIMESTAMP")
+
             return self.func(
-                f"{'TRY_' if expression.args.get('safe') else ''}TO_TIMESTAMP",
+                f"{'TRY_' if expression.args.get('safe') else ''}{func_name}",
                 expression.this,
                 self.format_time(expression),
             )

sqlglot/dialects/spark.py

@@ -4,6 +4,7 @@ import typing as t
 
 from sqlglot import exp
 from sqlglot.dialects.dialect import (
+    array_append_sql,
     rename_func,
     build_like,
     unit_to_var,
@@ -14,6 +15,7 @@ from sqlglot.dialects.dialect import (
 )
 from sqlglot.dialects.hive import _build_with_ignore_nulls
 from sqlglot.dialects.spark2 import Spark2, temporary_storage_provider, _build_as_cast
+from sqlglot.typing.spark import EXPRESSION_METADATA
 from sqlglot.helper import ensure_list, seq_get
 from sqlglot.tokens import TokenType
 from sqlglot.transforms import (
@@ -112,6 +114,8 @@ def _groupconcat_sql(self: Spark.Generator, expression: exp.GroupConcat) -> str:
 class Spark(Spark2):
     SUPPORTS_ORDER_BY_ALL = True
     SUPPORTS_NULL_TYPE = True
+    ARRAY_FUNCS_PROPAGATES_NULLS = True
+    EXPRESSION_METADATA = EXPRESSION_METADATA.copy()
 
     class Tokenizer(Spark2.Tokenizer):
         STRING_ESCAPES_ALLOWED_IN_RAW_STRINGS = False
@@ -126,6 +130,12 @@ class Spark(Spark2):
         FUNCTIONS = {
             **Spark2.Parser.FUNCTIONS,
             "ANY_VALUE": _build_with_ignore_nulls(exp.AnyValue),
+            "ARRAY_INSERT": lambda args: exp.ArrayInsert(
+                this=seq_get(args, 0),
+                position=seq_get(args, 1),
+                expression=seq_get(args, 2),
+                offset=1,
+            ),
             "BIT_AND": exp.BitwiseAndAgg.from_arg_list,
             "BIT_OR": exp.BitwiseOrAgg.from_arg_list,
             "BIT_XOR": exp.BitwiseXorAgg.from_arg_list,
@@ -139,6 +149,7 @@ class Spark(Spark2):
             "TRY_SUBTRACT": exp.SafeSubtract.from_arg_list,
             "DATEDIFF": _build_datediff,
             "DATE_DIFF": _build_datediff,
+            "JSON_OBJECT_KEYS": exp.JSONKeys.from_arg_list,
             "LISTAGG": exp.GroupConcat.from_arg_list,
             "TIMESTAMP_LTZ": _build_as_cast("TIMESTAMP_LTZ"),
             "TIMESTAMP_NTZ": _build_as_cast("TIMESTAMP_NTZ"),
@@ -162,6 +173,11 @@ class Spark(Spark2):
             self._match(TokenType.R_BRACE)
             return self.expression(exp.Placeholder, this=this, widget=True)
 
+        FUNCTION_PARSERS = {
+            **Spark2.Parser.FUNCTION_PARSERS,
+            "SUBSTR": lambda self: self._parse_substring(),
+        }
+
         def _parse_generated_as_identity(
             self,
         ) -> (
@@ -174,6 +190,12 @@ class Spark(Spark2):
                 return self.expression(exp.ComputedColumnConstraint, this=this.expression)
             return this
 
+        def _parse_pivot_aggregation(self) -> t.Optional[exp.Expression]:
+            # Spark 3+ and Databricks support non aggregate functions in PIVOT too, e.g
+            # PIVOT (..., 'foo' AS bar FOR col_to_pivot IN (...))
+            aggregate_expr = self._parse_function() or self._parse_disjunction()
+            return self._parse_alias(aggregate_expr)
+
     class Generator(Spark2.Generator):
         SUPPORTS_TO_NUMBER = True
         PAD_FILL_PATTERN_IS_REQUIRED = False
@@ -196,6 +218,8 @@ class Spark(Spark2):
             exp.ArrayConstructCompact: lambda self, e: self.func(
                 "ARRAY_COMPACT", self.func("ARRAY", *e.expressions)
             ),
+            exp.ArrayAppend: array_append_sql("ARRAY_APPEND"),
+            exp.ArrayPrepend: array_append_sql("ARRAY_PREPEND"),
             exp.BitwiseAndAgg: rename_func("BIT_AND"),
             exp.BitwiseOrAgg: rename_func("BIT_OR"),
             exp.BitwiseXorAgg: rename_func("BIT_XOR"),
@@ -214,6 +238,7 @@ class Spark(Spark2):
             exp.DatetimeSub: date_delta_to_binary_interval_op(cast=False),
             exp.GroupConcat: _groupconcat_sql,
             exp.EndsWith: rename_func("ENDSWITH"),
+            exp.JSONKeys: rename_func("JSON_OBJECT_KEYS"),
             exp.PartitionedByProperty: lambda self,
             e: f"PARTITIONED BY {self.wrap(self.expressions(sqls=[_normalize_partition(e) for e in e.this.expressions], skip_first=True))}",
             exp.SafeAdd: rename_func("TRY_ADD"),

sqlglot/dialects/spark2.py

@@ -9,11 +9,11 @@ from sqlglot.dialects.dialect import (
     is_parse_json,
     pivot_column_names,
     rename_func,
-    trim_sql,
     unit_to_str,
 )
 from sqlglot.dialects.hive import Hive
 from sqlglot.helper import seq_get
+from sqlglot.parser import build_trim
 from sqlglot.tokens import TokenType
 from sqlglot.transforms import (
     preprocess,
@@ -139,7 +139,6 @@ class Spark2(Hive):
         FUNCTIONS = {
             **Hive.Parser.FUNCTIONS,
             "AGGREGATE": exp.Reduce.from_arg_list,
-            "APPROX_PERCENTILE": exp.ApproxQuantile.from_arg_list,
             "BOOLEAN": _build_as_cast("boolean"),
             "DATE": _build_as_cast("date"),
             "DATE_TRUNC": lambda args: exp.TimestampTrunc(
@@ -159,9 +158,11 @@ class Spark2(Hive):
                 ),
                 zone=seq_get(args, 1),
             ),
+            "LTRIM": lambda args: build_trim(args, reverse_args=True),
             "INT": _build_as_cast("int"),
             "MAP_FROM_ARRAYS": exp.Map.from_arg_list,
             "RLIKE": exp.RegexpLike.from_arg_list,
+            "RTRIM": lambda args: build_trim(args, is_left=False, reverse_args=True),
             "SHIFTLEFT": binary_from_function(exp.BitwiseLeftShift),
             "SHIFTRIGHT": binary_from_function(exp.BitwiseRightShift),
             "STRING": _build_as_cast("string"),
@@ -187,6 +188,7 @@ class Spark2(Hive):
 
         FUNCTION_PARSERS = {
             **Hive.Parser.FUNCTION_PARSERS,
+            "APPROX_PERCENTILE": lambda self: self._parse_quantile_function(exp.ApproxQuantile),
             "BROADCAST": lambda self: self._parse_join_hint("BROADCAST"),
             "BROADCASTJOIN": lambda self: self._parse_join_hint("BROADCASTJOIN"),
             "MAPJOIN": lambda self: self._parse_join_hint("MAPJOIN"),
@@ -288,7 +290,6 @@ class Spark2(Hive):
             exp.StrToDate: _str_to_date,
             exp.StrToTime: lambda self, e: self.func("TO_TIMESTAMP", e.this, self.format_time(e)),
             exp.TimestampTrunc: lambda self, e: self.func("DATE_TRUNC", unit_to_str(e), e.this),
-            exp.Trim: trim_sql,
             exp.UnixToTime: _unix_to_time_sql,
             exp.VariancePop: rename_func("VAR_POP"),
             exp.WeekOfYear: rename_func("WEEKOFYEAR"),