sqlglot 27.27.0__py3-none-any.whl → 28.4.0__py3-none-any.whl

sqlglot/dialects/snowflake.py

@@ -6,12 +6,11 @@ from sqlglot import exp, generator, jsonpath, parser, tokens, transforms
 from sqlglot.dialects.dialect import (
     Dialect,
     NormalizationStrategy,
-    annotate_with_type_lambda,
     build_timetostr_or_tochar,
+    build_like,
     binary_from_function,
     build_default_decimal_type,
     build_replace_with_optional_replacement,
-    build_timestamp_from_parts,
     date_delta_sql,
     date_trunc_to_time,
     datestrtodate_sql,
@@ -23,6 +22,7 @@ from sqlglot.dialects.dialect import (
     rename_func,
     timestamptrunc_sql,
     timestrtotime_sql,
+    unit_to_str,
     var_map_sql,
     map_date_part,
     no_timestamp_sql,
@@ -33,9 +33,9 @@ from sqlglot.dialects.dialect import (
 )
 from sqlglot.generator import unsupported_args
 from sqlglot.helper import find_new_name, flatten, is_float, is_int, seq_get
-from sqlglot.optimizer.annotate_types import TypeAnnotator
 from sqlglot.optimizer.scope import build_scope, find_all_in_scope
 from sqlglot.tokens import TokenType
+from sqlglot.typing.snowflake import EXPRESSION_METADATA
 
 if t.TYPE_CHECKING:
     from sqlglot._typing import E, B
@@ -53,6 +53,21 @@ def _build_strtok(args: t.List) -> exp.SplitPart:
     return exp.SplitPart.from_arg_list(args)
 
 
+def _build_approx_top_k(args: t.List) -> exp.ApproxTopK:
+    """
+    Normalizes APPROX_TOP_K arguments to match Snowflake semantics.
+
+    Snowflake APPROX_TOP_K signature: APPROX_TOP_K(column [, k] [, counters])
+    - k defaults to 1 if omitted (per Snowflake documentation)
+    - counters is optional precision parameter
+    """
+    # Add default k=1 if only column is provided
+    if len(args) == 1:
+        args.append(exp.Literal.number(1))
+
+    return exp.ApproxTopK.from_arg_list(args)
+
+
 def _build_datetime(
     name: str, kind: exp.DataType.Type, safe: bool = False
 ) -> t.Callable[[t.List], exp.Func]:
@@ -128,6 +143,11 @@ def _build_date_time_add(expr_type: t.Type[E]) -> t.Callable[[t.List], E]:
 def _build_bitwise(expr_type: t.Type[B], name: str) -> t.Callable[[t.List], B | exp.Anonymous]:
     def _builder(args: t.List) -> B | exp.Anonymous:
         if len(args) == 3:
+            # Special handling for bitwise operations with padside argument
+            if expr_type in (exp.BitwiseAnd, exp.BitwiseOr, exp.BitwiseXor):
+                return expr_type(
+                    this=seq_get(args, 0), expression=seq_get(args, 1), padside=seq_get(args, 2)
+                )
             return exp.Anonymous(this=name, expressions=args)
 
         return binary_from_function(expr_type)(args)
@@ -344,8 +364,8 @@ def _transform_generate_date_array(expression: exp.Expression) -> exp.Expression
     return expression
 
 
-def _build_regexp_extract(expr_type: t.Type[E]) -> t.Callable[[t.List], E]:
-    def _builder(args: t.List) -> E:
+def _build_regexp_extract(expr_type: t.Type[E]) -> t.Callable[[t.List, Snowflake], E]:
+    def _builder(args: t.List, dialect: Snowflake) -> E:
         return expr_type(
             this=seq_get(args, 0),
             expression=seq_get(args, 1),
@@ -353,20 +373,16 @@ def _build_regexp_extract(expr_type: t.Type[E]) -> t.Callable[[t.List], E]:
             occurrence=seq_get(args, 3),
             parameters=seq_get(args, 4),
             group=seq_get(args, 5) or exp.Literal.number(0),
+            **(
+                {"null_if_pos_overflow": dialect.REGEXP_EXTRACT_POSITION_OVERFLOW_RETURNS_NULL}
+                if expr_type is exp.RegexpExtract
+                else {}
+            ),
         )
 
     return _builder
 
 
-def _build_like(expr_type: t.Type[E]) -> t.Callable[[t.List], E | exp.Escape]:
-    def _builder(args: t.List) -> E | exp.Escape:
-        like_expr = expr_type(this=args[0], expression=args[1])
-        escape = seq_get(args, 2)
-        return exp.Escape(this=like_expr, expression=escape) if escape else like_expr
-
-    return _builder
-
-
 def _regexpextract_sql(self, expression: exp.RegexpExtract | exp.RegexpExtractAll) -> str:
     # Other dialects don't support all of the following parameters, so we need to
     # generate default values as necessary to ensure the transpilation is correct
@@ -538,15 +554,57 @@ def _eliminate_dot_variant_lookup(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
-def _annotate_reverse(self: TypeAnnotator, expression: exp.Reverse) -> exp.Reverse:
-    expression = self._annotate_by_args(expression, "this")
-    if expression.is_type(exp.DataType.Type.NULL):
-        # Snowflake treats REVERSE(NULL) as a VARCHAR
-        self._set_type(expression, exp.DataType.Type.VARCHAR)
+def _build_timestamp_from_parts(args: t.List) -> exp.Func:
+    """Build TimestampFromParts with support for both syntaxes:
+    1. TIMESTAMP_FROM_PARTS(year, month, day, hour, minute, second [, nanosecond] [, time_zone])
+    2. TIMESTAMP_FROM_PARTS(date_expr, time_expr) - Snowflake specific
+    """
+    if len(args) == 2:
+        return exp.TimestampFromParts(this=seq_get(args, 0), expression=seq_get(args, 1))
+
+    return exp.TimestampFromParts.from_arg_list(args)
+
+
+def _build_round(args: t.List) -> exp.Round:
+    """
+    Build Round expression, unwrapping Snowflake's named parameters.
+
+    Maps EXPR => this, SCALE => decimals, ROUNDING_MODE => truncate.
 
+    Note: Snowflake does not support mixing named and positional arguments.
+    Arguments are either all named or all positional.
+    """
+    kwarg_map = {"EXPR": "this", "SCALE": "decimals", "ROUNDING_MODE": "truncate"}
+    round_args = {}
+    positional_keys = ["this", "decimals", "truncate"]
+    positional_idx = 0
+
+    for arg in args:
+        if isinstance(arg, exp.Kwarg):
+            key = arg.this.name.upper()
+            round_key = kwarg_map.get(key)
+            if round_key:
+                round_args[round_key] = arg.expression
+        else:
+            if positional_idx < len(positional_keys):
+                round_args[positional_keys[positional_idx]] = arg
+                positional_idx += 1
+
+    expression = exp.Round(**round_args)
+    expression.set("casts_non_integer_decimals", True)
     return expression
 
 
+def _build_try_to_number(args: t.List[exp.Expression]) -> exp.Expression:
+    return exp.ToNumber(
+        this=seq_get(args, 0),
+        format=seq_get(args, 1),
+        precision=seq_get(args, 2),
+        scale=seq_get(args, 3),
+        safe=True,
+    )
+
+
 class Snowflake(Dialect):
     # https://docs.snowflake.com/en/sql-reference/identifiers-syntax
     NORMALIZATION_STRATEGY = NormalizationStrategy.UPPERCASE
@@ -560,137 +618,12 @@ class Snowflake(Dialect):
     ARRAY_AGG_INCLUDES_NULLS = None
     ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN = False
     TRY_CAST_REQUIRES_STRING = True
+    SUPPORTS_ALIAS_REFS_IN_JOIN_CONDITIONS = True
 
-    TYPE_TO_EXPRESSIONS = {
-        **Dialect.TYPE_TO_EXPRESSIONS,
-        exp.DataType.Type.DOUBLE: {
-            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.DOUBLE],
-            exp.Cos,
-            exp.Cosh,
-            exp.Cot,
-            exp.Degrees,
-            exp.Exp,
-            exp.Sin,
-            exp.Sinh,
-            exp.Tan,
-            exp.Tanh,
-            exp.Asin,
-            exp.Asinh,
-            exp.Atan,
-            exp.Atan2,
-            exp.Atanh,
-            exp.Cbrt,
-        },
-        exp.DataType.Type.INT: {
-            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.INT],
-            exp.Ascii,
-            exp.ByteLength,
-            exp.Length,
-            exp.RtrimmedLength,
-            exp.BitLength,
-            exp.Levenshtein,
-            exp.JarowinklerSimilarity,
-            exp.StrPosition,
-            exp.Unicode,
-        },
-        exp.DataType.Type.VARCHAR: {
-            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.VARCHAR],
-            exp.Base64DecodeString,
-            exp.TryBase64DecodeString,
-            exp.Base64Encode,
-            exp.DecompressString,
-            exp.MD5,
-            exp.AIAgg,
-            exp.AIClassify,
-            exp.AISummarizeAgg,
-            exp.Chr,
-            exp.Collate,
-            exp.Collation,
-            exp.HexDecodeString,
-            exp.TryHexDecodeString,
-            exp.HexEncode,
-            exp.Initcap,
-            exp.RegexpExtract,
-            exp.RegexpReplace,
-            exp.Repeat,
-            exp.Replace,
-            exp.SHA,
-            exp.SHA2,
-            exp.Soundex,
-            exp.SoundexP123,
-            exp.Space,
-            exp.SplitPart,
-            exp.Translate,
-            exp.Uuid,
-        },
-        exp.DataType.Type.BINARY: {
-            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.BINARY],
-            exp.Base64DecodeBinary,
-            exp.TryBase64DecodeBinary,
-            exp.TryHexDecodeBinary,
-            exp.Compress,
-            exp.DecompressBinary,
-            exp.MD5Digest,
-            exp.SHA1Digest,
-            exp.SHA2Digest,
-            exp.Unhex,
-        },
-        exp.DataType.Type.BIGINT: {
-            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.BIGINT],
-            exp.Factorial,
-            exp.MD5NumberLower64,
-            exp.MD5NumberUpper64,
-        },
-        exp.DataType.Type.ARRAY: {
-            exp.Split,
-            exp.RegexpExtractAll,
-            exp.StringToArray,
-        },
-        exp.DataType.Type.OBJECT: {
-            exp.ParseUrl,
-            exp.ParseIp,
-        },
-        exp.DataType.Type.DECIMAL: {
-            exp.RegexpCount,
-        },
-        exp.DataType.Type.BOOLEAN: {
-            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.BOOLEAN],
-            exp.Search,
-        },
-    }
+    EXPRESSION_METADATA = EXPRESSION_METADATA.copy()
 
-    ANNOTATORS = {
-        **Dialect.ANNOTATORS,
-        **{
-            expr_type: annotate_with_type_lambda(data_type)
-            for data_type, expressions in TYPE_TO_EXPRESSIONS.items()
-            for expr_type in expressions
-        },
-        **{
-            expr_type: lambda self, e: self._annotate_by_args(e, "this")
-            for expr_type in (
-                exp.Floor,
-                exp.Left,
-                exp.Pad,
-                exp.Right,
-                exp.Stuff,
-                exp.Substring,
-                exp.Round,
-                exp.Ceil,
-            )
-        },
-        **{
-            expr_type: lambda self, e: self._annotate_with_type(
-                e, exp.DataType.build("NUMBER", dialect="snowflake")
-            )
-            for expr_type in (
-                exp.RegexpCount,
-                exp.RegexpInstr,
-            )
-        },
-        exp.ConcatWs: lambda self, e: self._annotate_by_args(e, "expressions"),
-        exp.Reverse: _annotate_reverse,
-    }
+    # https://docs.snowflake.com/en/en/sql-reference/functions/initcap
+    INITCAP_DEFAULT_DELIMITER_CHARS = ' \t\n\r\f\v!?@"^#$&~_,.:;+\\-*%/|\\[\\](){}<>'
 
     TIME_MAPPING = {
         "YYYY": "%Y",
@@ -724,17 +657,16 @@ class Snowflake(Dialect):
         "ISOWEEK": "WEEKISO",
     }
 
-    def quote_identifier(self, expression: E, identify: bool = True) -> E:
+    PSEUDOCOLUMNS = {"LEVEL"}
+
+    def can_quote(self, identifier: exp.Identifier, identify: str | bool = "safe") -> bool:
         # This disables quoting DUAL in SELECT ... FROM DUAL, because Snowflake treats an
         # unquoted DUAL keyword in a special way and does not map it to a user-defined table
-        if (
-            isinstance(expression, exp.Identifier)
-            and isinstance(expression.parent, exp.Table)
-            and expression.name.lower() == "dual"
-        ):
-            return expression  # type: ignore
-
-        return super().quote_identifier(expression, identify=identify)
+        return super().can_quote(identifier, identify) and not (
+            isinstance(identifier.parent, exp.Table)
+            and not identifier.quoted
+            and identifier.name.lower() == "dual"
+        )
 
     class JSONPathTokenizer(jsonpath.JSONPathTokenizer):
         SINGLE_TOKENS = jsonpath.JSONPathTokenizer.SINGLE_TOKENS.copy()
@@ -760,6 +692,7 @@ class Snowflake(Dialect):
         FUNCTIONS = {
             **parser.Parser.FUNCTIONS,
             "APPROX_PERCENTILE": exp.ApproxQuantile.from_arg_list,
+            "APPROX_TOP_K": _build_approx_top_k,
             "ARRAY_CONSTRUCT": lambda args: exp.Array(expressions=args),
             "ARRAY_CONTAINS": lambda args: exp.ArrayContains(
                 this=seq_get(args, 1), expression=seq_get(args, 0), ensure_variant=False
@@ -771,6 +704,10 @@ class Snowflake(Dialect):
                 step=seq_get(args, 2),
             ),
             "ARRAY_SORT": exp.SortArray.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)),
+            "BIT_NOT": lambda args: exp.BitwiseNot(this=seq_get(args, 0)),
             "BITXOR": _build_bitwise(exp.BitwiseXor, "BITXOR"),
             "BIT_XOR": _build_bitwise(exp.BitwiseXor, "BITXOR"),
             "BITOR": _build_bitwise(exp.BitwiseOr, "BITOR"),
@@ -791,6 +728,7 @@ class Snowflake(Dialect):
             "BITXOR_AGG": exp.BitwiseXorAgg.from_arg_list,
             "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"),
             "DATE": _build_datetime("DATE", exp.DataType.Type.DATE),
             "DATE_TRUNC": _date_trunc_to_time,
@@ -804,6 +742,7 @@ class Snowflake(Dialect):
             ),
             "FLATTEN": exp.Explode.from_arg_list,
             "GET": exp.GetExtract.from_arg_list,
+            "GETDATE": exp.CurrentTimestamp.from_arg_list,
             "GET_PATH": lambda args, dialect: exp.JSONExtract(
                 this=seq_get(args, 0),
                 expression=dialect.to_json_path(seq_get(args, 1)),
@@ -832,6 +771,7 @@ class Snowflake(Dialect):
             "REGEXP_SUBSTR_ALL": _build_regexp_extract(exp.RegexpExtractAll),
             "REPLACE": build_replace_with_optional_replacement,
             "RLIKE": exp.RegexpLike.from_arg_list,
+            "ROUND": _build_round,
             "SHA1_BINARY": exp.SHA1Digest.from_arg_list,
             "SHA1_HEX": exp.SHA.from_arg_list,
             "SHA2_BINARY": exp.SHA2Digest.from_arg_list,
@@ -843,23 +783,39 @@ class Snowflake(Dialect):
             "TIMEDIFF": _build_datediff,
             "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,
+            "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_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
+            ),
+            "TRY_TO_BOOLEAN": lambda args: exp.ToBoolean(this=seq_get(args, 0), safe=True),
             "TRY_TO_DATE": _build_datetime("TRY_TO_DATE", exp.DataType.Type.DATE, safe=True),
+            **dict.fromkeys(
+                ("TRY_TO_DECIMAL", "TRY_TO_NUMBER", "TRY_TO_NUMERIC"), _build_try_to_number
+            ),
+            "TRY_TO_DOUBLE": lambda args: exp.ToDouble(
+                this=seq_get(args, 0), format=seq_get(args, 1), safe=True
+            ),
+            "TRY_TO_FILE": lambda args: exp.ToFile(
+                this=seq_get(args, 0), path=seq_get(args, 1), safe=True
+            ),
             "TRY_TO_TIME": _build_datetime("TRY_TO_TIME", exp.DataType.Type.TIME, safe=True),
             "TRY_TO_TIMESTAMP": _build_datetime(
                 "TRY_TO_TIMESTAMP", exp.DataType.Type.TIMESTAMP, safe=True
             ),
             "TO_CHAR": build_timetostr_or_tochar,
             "TO_DATE": _build_datetime("TO_DATE", exp.DataType.Type.DATE),
-            "TO_NUMBER": lambda args: exp.ToNumber(
-                this=seq_get(args, 0),
-                format=seq_get(args, 1),
-                precision=seq_get(args, 2),
-                scale=seq_get(args, 3),
+            **dict.fromkeys(
+                ("TO_DECIMAL", "TO_NUMBER", "TO_NUMERIC"),
+                lambda args: exp.ToNumber(
+                    this=seq_get(args, 0),
+                    format=seq_get(args, 1),
+                    precision=seq_get(args, 2),
+                    scale=seq_get(args, 3),
+                ),
             ),
             "TO_TIME": _build_datetime("TO_TIME", exp.DataType.Type.TIME),
             "TO_TIMESTAMP": _build_datetime("TO_TIMESTAMP", exp.DataType.Type.TIMESTAMP),
@@ -868,11 +824,18 @@ class Snowflake(Dialect):
             "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,
+            "VECTOR_COSINE_SIMILARITY": exp.CosineDistance.from_arg_list,
+            "VECTOR_INNER_PRODUCT": exp.DotProduct.from_arg_list,
+            "VECTOR_L1_DISTANCE": exp.ManhattanDistance.from_arg_list,
             "VECTOR_L2_DISTANCE": exp.EuclideanDistance.from_arg_list,
             "ZEROIFNULL": _build_if_from_zeroifnull,
-            "LIKE": _build_like(exp.Like),
-            "ILIKE": _build_like(exp.ILike),
+            "LIKE": build_like(exp.Like),
+            "ILIKE": build_like(exp.ILike),
             "SEARCH": _build_search,
+            "SKEW": exp.Skewness.from_arg_list,
+            "SYSTIMESTAMP": exp.CurrentTimestamp.from_arg_list,
+            "WEEKISO": exp.WeekOfYear.from_arg_list,
+            "WEEKOFYEAR": exp.Week.from_arg_list,
         }
         FUNCTIONS.pop("PREDICT")
 
@@ -1078,30 +1041,11 @@ class Snowflake(Dialect):
             if not this:
                 return None
 
-            self._match(TokenType.COMMA)
-            expression = self._parse_bitwise()
-            this = map_date_part(this)
-            name = this.name.upper()
-
-            if name.startswith("EPOCH"):
-                if name == "EPOCH_MILLISECOND":
-                    scale = 10**3
-                elif name == "EPOCH_MICROSECOND":
-                    scale = 10**6
-                elif name == "EPOCH_NANOSECOND":
-                    scale = 10**9
-                else:
-                    scale = None
-
-                ts = self.expression(exp.Cast, this=expression, to=exp.DataType.build("TIMESTAMP"))
-                to_unix: exp.Expression = self.expression(exp.TimeToUnix, this=ts)
-
-                if scale:
-                    to_unix = exp.Mul(this=to_unix, expression=exp.Literal.number(scale))
-
-                return to_unix
-
-            return self.expression(exp.Extract, this=this, expression=expression)
+            # Handle both syntaxes: DATE_PART(part, expr) and DATE_PART(part FROM expr)
+            expression = (
+                self._match_set((TokenType.FROM, TokenType.COMMA)) and self._parse_bitwise()
+            )
+            return self.expression(exp.Extract, this=map_date_part(this), expression=expression)
 
         def _parse_bracket_key_value(self, is_map: bool = False) -> t.Optional[exp.Expression]:
             if is_map:
@@ -1237,19 +1181,17 @@ class Snowflake(Dialect):
 
             return self.expression(
                 exp.Show,
-                **{
-                    "terse": terse,
-                    "this": this,
-                    "history": history,
-                    "like": like,
-                    "scope": scope,
-                    "scope_kind": scope_kind,
-                    "starts_with": self._match_text_seq("STARTS", "WITH") and self._parse_string(),
-                    "limit": self._parse_limit(),
-                    "from": self._parse_string() if self._match(TokenType.FROM) else None,
-                    "privileges": self._match_text_seq("WITH", "PRIVILEGES")
-                    and self._parse_csv(lambda: self._parse_var(any_token=True, upper=True)),
-                },
+                terse=terse,
+                this=this,
+                history=history,
+                like=like,
+                scope=scope,
+                scope_kind=scope_kind,
+                starts_with=self._match_text_seq("STARTS", "WITH") and self._parse_string(),
+                limit=self._parse_limit(),
+                from_=self._parse_string() if self._match(TokenType.FROM) else None,
+                privileges=self._match_text_seq("WITH", "PRIVILEGES")
+                and self._parse_csv(lambda: self._parse_var(any_token=True, upper=True)),
             )
 
         def _parse_put(self) -> exp.Put | exp.Command:
@@ -1353,15 +1295,26 @@ class Snowflake(Dialect):
             kwargs: t.Dict[str, t.Any] = {"this": self._parse_table_parts()}
 
             while self._curr and not self._match(TokenType.R_PAREN, advance=False):
-                if self._match_text_seq("DIMENSIONS"):
-                    kwargs["dimensions"] = self._parse_csv(self._parse_disjunction)
-                if self._match_text_seq("METRICS"):
-                    kwargs["metrics"] = self._parse_csv(self._parse_disjunction)
-                if self._match_text_seq("WHERE"):
+                if self._match_texts(("DIMENSIONS", "METRICS", "FACTS")):
+                    keyword = self._prev.text.lower()
+                    kwargs[keyword] = self._parse_csv(self._parse_disjunction)
+                elif self._match_text_seq("WHERE"):
                     kwargs["where"] = self._parse_expression()
+                else:
+                    self.raise_error("Expecting ) or encountered unexpected keyword")
+                    break
 
             return self.expression(exp.SemanticView, **kwargs)
 
+        def _parse_set(self, unset: bool = False, tag: bool = False) -> exp.Set | exp.Command:
+            set = super()._parse_set(unset=unset, tag=tag)
+
+            if isinstance(set, exp.Set):
+                for expr in set.expressions:
+                    if isinstance(expr, exp.SetItem):
+                        expr.set("kind", "VARIABLE")
+            return set
+
     class Tokenizer(tokens.Tokenizer):
         STRING_ESCAPES = ["\\", "'"]
         HEX_STRINGS = [("x'", "'"), ("X'", "'")]
@@ -1393,6 +1346,9 @@ class Snowflake(Dialect):
             "TIMESTAMP_TZ": TokenType.TIMESTAMPTZ,
             "TOP": TokenType.TOP,
             "WAREHOUSE": TokenType.WAREHOUSE,
+            # https://docs.snowflake.com/en/sql-reference/data-types-numeric#float
+            # FLOAT is a synonym for DOUBLE in Snowflake
+            "FLOAT": TokenType.DOUBLE,
         }
         KEYWORDS.pop("/*+")
 
@@ -1437,6 +1393,7 @@ class Snowflake(Dialect):
             exp.ApproxDistinct: rename_func("APPROX_COUNT_DISTINCT"),
             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.ArrayContains: lambda self, e: self.func(
                 "ARRAY_CONTAINS",
@@ -1468,10 +1425,12 @@ class Snowflake(Dialect):
             exp.DayOfWeek: rename_func("DAYOFWEEK"),
             exp.DayOfWeekIso: rename_func("DAYOFWEEKISO"),
             exp.DayOfYear: rename_func("DAYOFYEAR"),
+            exp.DotProduct: rename_func("VECTOR_INNER_PRODUCT"),
             exp.Explode: rename_func("FLATTEN"),
             exp.Extract: lambda self, e: self.func(
                 "DATE_PART", map_date_part(e.this, self.dialect), e.expression
             ),
+            exp.CosineDistance: rename_func("VECTOR_COSINE_SIMILARITY"),
             exp.EuclideanDistance: rename_func("VECTOR_L2_DISTANCE"),
             exp.FileFormatProperty: lambda self,
             e: f"FILE_FORMAT=({self.expressions(e, 'expressions', sep=' ')})",
@@ -1498,11 +1457,31 @@ class Snowflake(Dialect):
             exp.LogicalAnd: rename_func("BOOLAND_AGG"),
             exp.LogicalOr: rename_func("BOOLOR_AGG"),
             exp.Map: lambda self, e: var_map_sql(self, e, "OBJECT_CONSTRUCT"),
+            exp.ManhattanDistance: rename_func("VECTOR_L1_DISTANCE"),
             exp.MakeInterval: no_make_interval_sql,
             exp.Max: max_or_greatest,
             exp.Min: min_or_least,
             exp.ParseJSON: lambda self, e: self.func(
-                "TRY_PARSE_JSON" if e.args.get("safe") else "PARSE_JSON", e.this
+                f"{'TRY_' if e.args.get('safe') else ''}PARSE_JSON", e.this
+            ),
+            exp.ToBinary: lambda self, e: self.func(
+                f"{'TRY_' if e.args.get('safe') else ''}TO_BINARY", e.this, e.args.get("format")
+            ),
+            exp.ToBoolean: lambda self, e: self.func(
+                f"{'TRY_' if e.args.get('safe') else ''}TO_BOOLEAN", e.this
+            ),
+            exp.ToDouble: lambda self, e: self.func(
+                f"{'TRY_' if e.args.get('safe') else ''}TO_DOUBLE", e.this, e.args.get("format")
+            ),
+            exp.ToFile: lambda self, e: self.func(
+                f"{'TRY_' if e.args.get('safe') else ''}TO_FILE", e.this, e.args.get("path")
+            ),
+            exp.ToNumber: lambda self, e: self.func(
+                f"{'TRY_' if e.args.get('safe') else ''}TO_NUMBER",
+                e.this,
+                e.args.get("format"),
+                e.args.get("precision"),
+                e.args.get("scale"),
             ),
             exp.JSONFormat: rename_func("TO_JSON"),
             exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
@@ -1529,11 +1508,13 @@ class Snowflake(Dialect):
                 ]
             ),
             exp.SHA: rename_func("SHA1"),
+            exp.SHA1Digest: rename_func("SHA1_BINARY"),
             exp.MD5Digest: rename_func("MD5_BINARY"),
             exp.MD5NumberLower64: rename_func("MD5_NUMBER_LOWER64"),
             exp.MD5NumberUpper64: rename_func("MD5_NUMBER_UPPER64"),
             exp.LowerHex: rename_func("TO_CHAR"),
             exp.SortArray: rename_func("ARRAY_SORT"),
+            exp.Skewness: rename_func("SKEW"),
             exp.StarMap: rename_func("OBJECT_CONSTRUCT"),
             exp.StartsWith: rename_func("STARTSWITH"),
             exp.EndsWith: rename_func("ENDSWITH"),
@@ -1545,6 +1526,13 @@ class Snowflake(Dialect):
             exp.Stuff: rename_func("INSERT"),
             exp.StPoint: rename_func("ST_MAKEPOINT"),
             exp.TimeAdd: date_delta_sql("TIMEADD"),
+            exp.TimeSlice: lambda self, e: self.func(
+                "TIME_SLICE",
+                e.this,
+                e.expression,
+                unit_to_str(e),
+                e.args.get("kind"),
+            ),
             exp.Timestamp: no_timestamp_sql,
             exp.TimestampAdd: date_delta_sql("TIMESTAMPADD"),
             exp.TimestampDiff: lambda self, e: self.func(
@@ -1555,22 +1543,31 @@ class Snowflake(Dialect):
             exp.TimeToUnix: lambda self, e: f"EXTRACT(epoch_second FROM {self.sql(e, 'this')})",
             exp.ToArray: rename_func("TO_ARRAY"),
             exp.ToChar: lambda self, e: self.function_fallback_sql(e),
-            exp.ToDouble: rename_func("TO_DOUBLE"),
             exp.TsOrDsAdd: date_delta_sql("DATEADD", cast=True),
             exp.TsOrDsDiff: date_delta_sql("DATEDIFF"),
             exp.TsOrDsToDate: lambda self, e: self.func(
-                "TRY_TO_DATE" if e.args.get("safe") else "TO_DATE", e.this, self.format_time(e)
+                f"{'TRY_' if e.args.get('safe') else ''}TO_DATE", e.this, self.format_time(e)
             ),
             exp.TsOrDsToTime: lambda self, e: self.func(
-                "TRY_TO_TIME" if e.args.get("safe") else "TO_TIME", e.this, self.format_time(e)
+                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.Uuid: rename_func("UUID_STRING"),
             exp.VarMap: lambda self, e: var_map_sql(self, e, "OBJECT_CONSTRUCT"),
-            exp.WeekOfYear: rename_func("WEEKOFYEAR"),
+            exp.Booland: rename_func("BOOLAND"),
+            exp.Boolor: rename_func("BOOLOR"),
+            exp.WeekOfYear: rename_func("WEEKISO"),
+            exp.YearOfWeek: rename_func("YEAROFWEEK"),
+            exp.YearOfWeekIso: rename_func("YEAROFWEEKISO"),
             exp.Xor: rename_func("BOOLXOR"),
             exp.ByteLength: rename_func("OCTET_LENGTH"),
+            exp.ArrayConcatAgg: lambda self, e: self.func(
+                "ARRAY_FLATTEN", exp.ArrayAgg(this=e.this)
+            ),
+            exp.SHA2Digest: lambda self, e: self.func(
+                "SHA2_BINARY", e.this, e.args.get("length") or exp.Literal.number(256)
+            ),
         }
 
         SUPPORTED_JSON_PATH_PARTS = {
@@ -1619,6 +1616,15 @@ class Snowflake(Dialect):
             return super().values_sql(expression, values_as_table=values_as_table)
 
         def datatype_sql(self, expression: exp.DataType) -> str:
+            # Check if this is a FLOAT type nested inside a VECTOR type
+            # VECTOR only accepts FLOAT (not DOUBLE), INT, and STRING as element types
+            # https://docs.snowflake.com/en/sql-reference/data-types-vector
+            if expression.is_type(exp.DataType.Type.DOUBLE):
+                parent = expression.parent
+                if isinstance(parent, exp.DataType) and parent.is_type(exp.DataType.Type.VECTOR):
+                    # Preserve FLOAT for VECTOR types instead of mapping to synonym DOUBLE
+                    return "FLOAT"
+
             expressions = expression.expressions
             if expressions and expression.is_type(*exp.DataType.STRUCT_TYPES):
                 for field_type in expressions:
@@ -1748,7 +1754,7 @@ class Snowflake(Dialect):
 
             limit = self.sql(expression, "limit")
 
-            from_ = self.sql(expression, "from")
+            from_ = self.sql(expression, "from_")
             if from_:
                 from_ = f" FROM {from_}"
 
@@ -1824,9 +1830,10 @@ class Snowflake(Dialect):
             return f"SET{exprs}{file_format}{copy_options}{tag}"
 
         def strtotime_sql(self, expression: exp.StrToTime):
-            safe_prefix = "TRY_" if expression.args.get("safe") else ""
             return self.func(
-                f"{safe_prefix}TO_TIMESTAMP", expression.this, self.format_time(expression)
+                f"{'TRY_' if expression.args.get('safe') else ''}TO_TIMESTAMP",
+                expression.this,
+                self.format_time(expression),
             )
 
         def timestampsub_sql(self, expression: exp.TimestampSub):
@@ -1984,3 +1991,17 @@ class Snowflake(Dialect):
                 expression.set("part_index", exp.Literal.number(1))
 
             return rename_func("SPLIT_PART")(self, expression)
+
+        def uniform_sql(self, expression: exp.Uniform) -> str:
+            gen = expression.args.get("gen")
+            seed = expression.args.get("seed")
+
+            # From Databricks UNIFORM(min, max, seed) -> Wrap gen in RANDOM(seed)
+            if seed:
+                gen = exp.Rand(this=seed)
+
+            # No gen argument (from Databricks 2-arg UNIFORM(min, max)) -> Add RANDOM()
+            if not gen:
+                gen = exp.Rand()
+
+            return self.func("UNIFORM", expression.this, expression.expression, gen)