sqlglot 27.13.2__tar.gz → 27.14.0__tar.gz

{sqlglot-27.13.2 → sqlglot-27.14.0}/CHANGELOG.md

@@ -1,6 +1,11 @@
 Changelog
 =========
 
+## [v27.13.2] - 2025-09-08
+### :bug: Bug Fixes
+- [`5e7979f`](https://github.com/tobymao/sqlglot/commit/5e7979f3cf5f7996e198ddd81069d49a4a3b9391) - select session *(PR [#5836](https://github.com/tobymao/sqlglot/pull/5836) by [@tobymao](https://github.com/tobymao))*
+
+
 ## [v27.13.1] - 2025-09-08
 ### :bug: Bug Fixes
 - [`f3d55c0`](https://github.com/tobymao/sqlglot/commit/f3d55c05c8411c9871f8ca4d23f726f976c9236b) - remove always token *(PR [#5832](https://github.com/tobymao/sqlglot/pull/5832) by [@tobymao](https://github.com/tobymao))*
@@ -7172,3 +7177,4 @@ Changelog
 [v27.12.0]: https://github.com/tobymao/sqlglot/compare/v27.11.0...v27.12.0
 [v27.13.0]: https://github.com/tobymao/sqlglot/compare/v27.12.0...v27.13.0
 [v27.13.1]: https://github.com/tobymao/sqlglot/compare/v27.13.0...v27.13.1
+[v27.13.2]: https://github.com/tobymao/sqlglot/compare/v27.13.1...v27.13.2

{sqlglot-27.13.2 → sqlglot-27.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglot
-Version: 27.13.2
+Version: 27.14.0
 Summary: An easily customizable SQL parser and transpiler
 Author-email: Toby Mao <toby.mao@gmail.com>
 License-Expression: MIT

{sqlglot-27.13.2 → sqlglot-27.14.0}/sqlglot/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '27.13.2'
-__version_tuple__ = version_tuple = (27, 13, 2)
+__version__ = version = '27.14.0'
+__version_tuple__ = version_tuple = (27, 14, 0)
 
-__commit_id__ = commit_id = 'g5e7979f3c'
+__commit_id__ = commit_id = 'gb244f3052'

{sqlglot-27.13.2 → sqlglot-27.14.0}/sqlglot/dialects/bigquery.py

@@ -859,10 +859,12 @@ class BigQuery(Dialect):
                 exp.JSONArray, expressions=self._parse_csv(self._parse_bitwise)
             ),
             "MAKE_INTERVAL": lambda self: self._parse_make_interval(),
-            "PREDICT": lambda self: self._parse_predict(),
+            "PREDICT": lambda self: self._parse_ml(exp.Predict),
+            "TRANSLATE": lambda self: self._parse_translate(),
             "FEATURES_AT_TIME": lambda self: self._parse_features_at_time(),
-            "GENERATE_EMBEDDING": lambda self: self._parse_generate_embedding(),
+            "GENERATE_EMBEDDING": lambda self: self._parse_ml(exp.GenerateEmbedding),
             "VECTOR_SEARCH": lambda self: self._parse_vector_search(),
+            "FORECAST": lambda self: self._parse_ml(exp.MLForecast),
         }
         FUNCTION_PARSERS.pop("TRIM")
 
@@ -1146,34 +1148,35 @@ class BigQuery(Dialect):
 
             return expr
 
-        def _parse_predict(self) -> exp.Predict:
+        def _parse_ml(self, expr_type: t.Type[E]) -> E:
             self._match_text_seq("MODEL")
             this = self._parse_table()
 
             self._match(TokenType.COMMA)
             self._match_text_seq("TABLE")
 
-            return self.expression(
-                exp.Predict,
-                this=this,
-                expression=self._parse_table(),
-                params_struct=self._match(TokenType.COMMA) and self._parse_bitwise(),
+            # Certain functions like ML.FORECAST require a STRUCT argument but not a TABLE/SELECT one
+            expression = (
+                self._parse_table() if not self._match(TokenType.STRUCT, advance=False) else None
             )
 
-        def _parse_generate_embedding(self) -> exp.GenerateEmbedding:
-            self._match_text_seq("MODEL")
-            this = self._parse_table()
-
             self._match(TokenType.COMMA)
-            self._match_text_seq("TABLE")
 
             return self.expression(
-                exp.GenerateEmbedding,
+                expr_type,
                 this=this,
-                expression=self._parse_table(),
-                params_struct=self._match(TokenType.COMMA) and self._parse_bitwise(),
+                expression=expression,
+                params_struct=self._parse_bitwise(),
             )
 
+        def _parse_translate(self) -> exp.Translate | exp.MLTranslate:
+            # Check if this is ML.TRANSLATE by looking at previous tokens
+            token = seq_get(self._tokens, self._index - 4)
+            if token and token.text.upper() == "ML":
+                return self._parse_ml(exp.MLTranslate)
+
+            return exp.Translate.from_arg_list(self._parse_function_args())
+
         def _parse_features_at_time(self) -> exp.FeaturesAtTime:
             self._match(TokenType.TABLE)
             this = self._parse_table()

{sqlglot-27.13.2 → sqlglot-27.14.0}/sqlglot/dialects/clickhouse.py

@@ -189,6 +189,7 @@ def _map_sql(self: ClickHouse.Generator, expression: exp.Map | exp.VarMap) -> st
 
 
 class ClickHouse(Dialect):
+    INDEX_OFFSET = 1
     NORMALIZE_FUNCTIONS: bool | str = False
     NULL_ORDERING = "nulls_are_last"
     SUPPORTS_USER_DEFINED_TYPES = False

{sqlglot-27.13.2 → sqlglot-27.14.0}/sqlglot/dialects/dialect.py

@@ -674,6 +674,7 @@ class Dialect(metaclass=_Dialect):
         exp.DataType.Type.BOOLEAN: {
             exp.Between,
             exp.Boolean,
+            exp.Contains,
             exp.EndsWith,
             exp.In,
             exp.LogicalAnd,
@@ -818,7 +819,6 @@ class Dialect(metaclass=_Dialect):
         exp.Cast: lambda self, e: self._annotate_with_type(e, e.args["to"]),
         exp.Case: lambda self, e: self._annotate_by_args(e, "default", "ifs"),
         exp.Coalesce: lambda self, e: self._annotate_by_args(e, "this", "expressions"),
-        exp.Contains: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.BOOLEAN),
         exp.Count: lambda self, e: self._annotate_with_type(
             e, exp.DataType.Type.BIGINT if e.args.get("big_int") else exp.DataType.Type.INT
         ),

{sqlglot-27.13.2 → sqlglot-27.14.0}/sqlglot/dialects/duckdb.py

@@ -365,6 +365,9 @@ class DuckDB(Dialect):
             "ANY_VALUE": lambda args: exp.IgnoreNulls(this=exp.AnyValue.from_arg_list(args)),
             "ARRAY_REVERSE_SORT": _build_sort_array_desc,
             "ARRAY_SORT": exp.SortArray.from_arg_list,
+            "BIT_AND": exp.BitwiseAndAgg.from_arg_list,
+            "BIT_OR": exp.BitwiseOrAgg.from_arg_list,
+            "BIT_XOR": exp.BitwiseXorAgg.from_arg_list,
             "DATEDIFF": _build_date_diff,
             "DATE_DIFF": _build_date_diff,
             "DATE_TRUNC": date_trunc_to_time,
@@ -649,7 +652,10 @@ class DuckDB(Dialect):
             exp.ArrayUniqueAgg: lambda self, e: self.func(
                 "LIST", exp.Distinct(expressions=[e.this])
             ),
+            exp.BitwiseAndAgg: rename_func("BIT_AND"),
+            exp.BitwiseOrAgg: rename_func("BIT_OR"),
             exp.BitwiseXor: rename_func("XOR"),
+            exp.BitwiseXorAgg: rename_func("BIT_XOR"),
             exp.CommentColumnConstraint: no_comment_column_constraint_sql,
             exp.CosineDistance: rename_func("LIST_COSINE_DISTANCE"),
             exp.CurrentDate: lambda *_: "CURRENT_DATE",
@@ -995,13 +1001,18 @@ class DuckDB(Dialect):
 
         def join_sql(self, expression: exp.Join) -> str:
             if (
-                expression.side == "LEFT"
+                not expression.args.get("using")
                 and not expression.args.get("on")
-                and isinstance(expression.this, exp.Unnest)
+                and not expression.method
+                and (expression.kind in ("", "INNER", "OUTER"))
             ):
-                # Some dialects support `LEFT JOIN UNNEST(...)` without an explicit ON clause
+                # Some dialects support `LEFT/INNER JOIN UNNEST(...)` without an explicit ON clause
                 # DuckDB doesn't, but we can just add a dummy ON clause that is always true
-                return super().join_sql(expression.on(exp.true()))
+                if isinstance(expression.this, exp.Unnest):
+                    return super().join_sql(expression.on(exp.true()))
+
+                expression.args.pop("side", None)
+                expression.args.pop("kind", None)
 
             return super().join_sql(expression)
 

{sqlglot-27.13.2 → sqlglot-27.14.0}/sqlglot/dialects/fabric.py

@@ -125,7 +125,7 @@ class Fabric(TSQL):
             exp.DataType.Type.TIMESTAMPTZ: "DATETIME2",
             exp.DataType.Type.TINYINT: "SMALLINT",
             exp.DataType.Type.UTINYINT: "SMALLINT",
-            exp.DataType.Type.UUID: "VARBINARY(MAX)",
+            exp.DataType.Type.UUID: "UNIQUEIDENTIFIER",
             exp.DataType.Type.XML: "VARCHAR",
         }
 

{sqlglot-27.13.2 → sqlglot-27.14.0}/sqlglot/dialects/hive.py

@@ -309,6 +309,7 @@ class Hive(Dialect):
         STRICT_CAST = False
         VALUES_FOLLOWED_BY_PAREN = False
         JOINS_HAVE_EQUAL_PRECEDENCE = True
+        ADD_JOIN_ON_TRUE = True
 
         FUNCTIONS = {
             **parser.Parser.FUNCTIONS,

{sqlglot-27.13.2 → sqlglot-27.14.0}/sqlglot/dialects/mysql.py

@@ -579,9 +579,11 @@ class MySQL(Dialect):
             full: t.Optional[bool] = None,
             global_: t.Optional[bool] = None,
         ) -> exp.Show:
+            json = self._match_text_seq("JSON")
+
             if target:
                 if isinstance(target, str):
-                    self._match_text_seq(target)
+                    self._match_text_seq(*target.split(" "))
                 target_id = self._parse_id_var()
             else:
                 target_id = None
@@ -618,6 +620,12 @@ class MySQL(Dialect):
             mutex = True if self._match_text_seq("MUTEX") else None
             mutex = False if self._match_text_seq("STATUS") else mutex
 
+            for_table = self._parse_id_var() if self._match_text_seq("FOR", "TABLE") else None
+            for_group = self._parse_string() if self._match_text_seq("FOR", "GROUP") else None
+            for_user = self._parse_string() if self._match_text_seq("FOR", "USER") else None
+            for_role = self._parse_string() if self._match_text_seq("FOR", "ROLE") else None
+            into_outfile = self._parse_string() if self._match_text_seq("INTO", "OUTFILE") else None
+
             return self.expression(
                 exp.Show,
                 this=this,
@@ -634,6 +642,12 @@ class MySQL(Dialect):
                 offset=offset,
                 limit=limit,
                 mutex=mutex,
+                for_table=for_table,
+                for_group=for_group,
+                for_user=for_user,
+                for_role=for_role,
+                into_outfile=into_outfile,
+                json=json,
                 **{"global": global_},  # type: ignore
             )
 
@@ -1200,6 +1214,10 @@ class MySQL(Dialect):
                 target = f" FROM{target}"
             elif expression.name == "GRANTS":
                 target = f" FOR{target}"
+            elif expression.name in ("LINKS", "PARTITIONS"):
+                target = f" ON{target}" if target else ""
+            elif expression.name == "PROJECTIONS":
+                target = f" ON TABLE{target}" if target else ""
 
             db = self._prefixed_sql("FROM", expression, "db")
 
@@ -1227,7 +1245,14 @@ class MySQL(Dialect):
             else:
                 mutex_or_status = ""
 
-            return f"SHOW{full}{global_}{this}{target}{types}{db}{query}{log}{position}{channel}{mutex_or_status}{like}{where}{offset}{limit}"
+            for_table = self._prefixed_sql("FOR TABLE", expression, "for_table")
+            for_group = self._prefixed_sql("FOR GROUP", expression, "for_group")
+            for_user = self._prefixed_sql("FOR USER", expression, "for_user")
+            for_role = self._prefixed_sql("FOR ROLE", expression, "for_role")
+            into_outfile = self._prefixed_sql("INTO OUTFILE", expression, "into_outfile")
+            json = " JSON" if expression.args.get("json") else ""
+
+            return f"SHOW{full}{global_}{this}{json}{target}{for_table}{types}{db}{query}{log}{position}{channel}{mutex_or_status}{like}{where}{offset}{limit}{for_group}{for_user}{for_role}{into_outfile}"
 
         def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
             dtype = self.sql(expression, "dtype")

{sqlglot-27.13.2 → sqlglot-27.14.0}/sqlglot/dialects/postgres.py

@@ -325,6 +325,9 @@ class Postgres(Dialect):
             "@@": TokenType.DAT,
             "@>": TokenType.AT_GT,
             "<@": TokenType.LT_AT,
+            "?&": TokenType.QMARK_AMP,
+            "?|": TokenType.QMARK_PIPE,
+            "#-": TokenType.HASH_DASH,
             "|/": TokenType.PIPE_SLASH,
             "||/": TokenType.DPIPE_SLASH,
             "BEGIN": TokenType.BEGIN,
@@ -386,6 +389,9 @@ class Postgres(Dialect):
 
         FUNCTIONS = {
             **parser.Parser.FUNCTIONS,
+            "BIT_AND": exp.BitwiseAndAgg.from_arg_list,
+            "BIT_OR": exp.BitwiseOrAgg.from_arg_list,
+            "BIT_XOR": exp.BitwiseXorAgg.from_arg_list,
             "DATE_TRUNC": build_timestamp_trunc,
             "DIV": lambda args: exp.cast(
                 binary_from_function(exp.IntDiv)(args), exp.DataType.Type.DECIMAL
@@ -584,7 +590,10 @@ class Postgres(Dialect):
             exp.AnyValue: _versioned_anyvalue_sql,
             exp.ArrayConcat: lambda self, e: self.arrayconcat_sql(e, name="ARRAY_CAT"),
             exp.ArrayFilter: filter_array_using_unnest,
+            exp.BitwiseAndAgg: rename_func("BIT_AND"),
+            exp.BitwiseOrAgg: rename_func("BIT_OR"),
             exp.BitwiseXor: lambda self, e: self.binary(e, "#"),
+            exp.BitwiseXorAgg: rename_func("BIT_XOR"),
             exp.ColumnDef: transforms.preprocess([_auto_increment_to_serial, _serial_to_generated]),
             exp.CurrentDate: no_paren_current_date_sql,
             exp.CurrentTimestamp: lambda *_: "CURRENT_TIMESTAMP",

{sqlglot-27.13.2 → sqlglot-27.14.0}/sqlglot/dialects/redshift.py

@@ -162,6 +162,7 @@ class Redshift(Postgres):
         ALTER_SET_TYPE = "TYPE"
         SUPPORTS_DECODE_CASE = True
         SUPPORTS_BETWEEN_FLAGS = False
+        LIMIT_FETCH = "LIMIT"
 
         # Redshift doesn't have `WITH` as part of their with_properties so we remove it
         WITH_PROPERTIES_PREFIX = " "

{sqlglot-27.13.2 → sqlglot-27.14.0}/sqlglot/dialects/singlestore.py

@@ -16,7 +16,7 @@ from sqlglot.dialects.dialect import (
     date_add_interval_sql,
     timestampdiff_sql,
 )
-from sqlglot.dialects.mysql import MySQL, _remove_ts_or_ds_to_date, date_add_sql
+from sqlglot.dialects.mysql import MySQL, _remove_ts_or_ds_to_date, date_add_sql, _show_parser
 from sqlglot.expressions import DataType
 from sqlglot.generator import unsupported_args
 from sqlglot.helper import seq_get
@@ -55,6 +55,17 @@ class SingleStore(MySQL):
         "FF6": "%f",  # only 6 digits are supported in python formats
     }
 
+    VECTOR_TYPE_ALIASES = {
+        "I8": "TINYINT",
+        "I16": "SMALLINT",
+        "I32": "INT",
+        "I64": "BIGINT",
+        "F32": "FLOAT",
+        "F64": "DOUBLE",
+    }
+
+    INVERSE_VECTOR_TYPE_ALIASES = {v: k for k, v in VECTOR_TYPE_ALIASES.items()}
+
     class Tokenizer(MySQL.Tokenizer):
         BYTE_STRINGS = [("e'", "'"), ("E'", "'")]
 
@@ -249,6 +260,63 @@ class SingleStore(MySQL):
         COLUMN_OPERATORS.pop(TokenType.DHASH_ARROW)
         COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER)
 
+        SHOW_PARSERS = {
+            **MySQL.Parser.SHOW_PARSERS,
+            "AGGREGATES": _show_parser("AGGREGATES"),
+            "CDC EXTRACTOR POOL": _show_parser("CDC EXTRACTOR POOL"),
+            "CREATE AGGREGATE": _show_parser("CREATE AGGREGATE", target=True),
+            "CREATE PIPELINE": _show_parser("CREATE PIPELINE", target=True),
+            "CREATE PROJECTION": _show_parser("CREATE PROJECTION", target=True),
+            "DATABASE STATUS": _show_parser("DATABASE STATUS"),
+            "DISTRIBUTED_PLANCACHE STATUS": _show_parser("DISTRIBUTED_PLANCACHE STATUS"),
+            "FULLTEXT SERVICE METRICS LOCAL": _show_parser("FULLTEXT SERVICE METRICS LOCAL"),
+            "FULLTEXT SERVICE METRICS FOR NODE": _show_parser(
+                "FULLTEXT SERVICE METRICS FOR NODE", target=True
+            ),
+            "FULLTEXT SERVICE STATUS": _show_parser("FULLTEXT SERVICE STATUS"),
+            "FUNCTIONS": _show_parser("FUNCTIONS"),
+            "GROUPS": _show_parser("GROUPS"),
+            "GROUPS FOR ROLE": _show_parser("GROUPS FOR ROLE", target=True),
+            "GROUPS FOR USER": _show_parser("GROUPS FOR USER", target=True),
+            "INDEXES": _show_parser("INDEX", target="FROM"),
+            "KEYS": _show_parser("INDEX", target="FROM"),
+            "LINKS": _show_parser("LINKS", target="ON"),
+            "LOAD ERRORS": _show_parser("LOAD ERRORS"),
+            "LOAD WARNINGS": _show_parser("LOAD WARNINGS"),
+            "PARTITIONS": _show_parser("PARTITIONS", target="ON"),
+            "PIPELINES": _show_parser("PIPELINES"),
+            "PLAN": _show_parser("PLAN", target=True),
+            "PLANCACHE": _show_parser("PLANCACHE"),
+            "PROCEDURES": _show_parser("PROCEDURES"),
+            "PROJECTIONS": _show_parser("PROJECTIONS", target="ON TABLE"),
+            "REPLICATION STATUS": _show_parser("REPLICATION STATUS"),
+            "REPRODUCTION": _show_parser("REPRODUCTION"),
+            "RESOURCE POOLS": _show_parser("RESOURCE POOLS"),
+            "ROLES": _show_parser("ROLES"),
+            "ROLES FOR USER": _show_parser("ROLES FOR USER", target=True),
+            "ROLES FOR GROUP": _show_parser("ROLES FOR GROUP", target=True),
+            "STATUS EXTENDED": _show_parser("STATUS EXTENDED"),
+            "USERS": _show_parser("USERS"),
+            "USERS FOR ROLE": _show_parser("USERS FOR ROLE", target=True),
+            "USERS FOR GROUP": _show_parser("USERS FOR GROUP", target=True),
+        }
+
+        ALTER_PARSERS = {
+            **MySQL.Parser.ALTER_PARSERS,
+            "CHANGE": lambda self: self.expression(
+                exp.RenameColumn, this=self._parse_column(), to=self._parse_column()
+            ),
+        }
+
+        def _parse_vector_expressions(
+            self, expressions: t.List[exp.Expression]
+        ) -> t.List[exp.Expression]:
+            type_name = expressions[1].name.upper()
+            if type_name in self.dialect.VECTOR_TYPE_ALIASES:
+                type_name = self.dialect.VECTOR_TYPE_ALIASES[type_name]
+
+            return [exp.DataType.build(type_name, dialect=self.dialect), expressions[0]]
+
     class Generator(MySQL.Generator):
         SUPPORTS_UESCAPE = False
         NULL_ORDERING_SUPPORTED = True
@@ -467,6 +535,29 @@ class SingleStore(MySQL):
             exp.MatchAgainst: unsupported_args("modifier")(
                 lambda self, e: super().matchagainst_sql(e)
             ),
+            exp.Show: unsupported_args(
+                "history",
+                "terse",
+                "offset",
+                "starts_with",
+                "limit",
+                "from",
+                "scope",
+                "scope_kind",
+                "mutex",
+                "query",
+                "channel",
+                "log",
+                "types",
+                "privileges",
+            )(lambda self, e: super().show_sql(e)),
+            exp.Describe: unsupported_args(
+                "style",
+                "kind",
+                "expressions",
+                "partition",
+                "format",
+            )(lambda self, e: super().describe_sql(e)),
         }
         TRANSFORMS.pop(exp.JSONExtractScalar)
         TRANSFORMS.pop(exp.CurrentDate)
@@ -1685,6 +1776,14 @@ class SingleStore(MySQL):
                     return f"DECIMAL({precision}, {scale[0]})"
                 else:
                     return f"DECIMAL({precision})"
+            if expression.is_type(exp.DataType.Type.VECTOR):
+                expressions = expression.expressions
+                if len(expressions) == 2:
+                    type_name = self.sql(expressions[0])
+                    if type_name in self.dialect.INVERSE_VECTOR_TYPE_ALIASES:
+                        type_name = self.dialect.INVERSE_VECTOR_TYPE_ALIASES[type_name]
+
+                    return f"VECTOR({self.sql(expressions[1])}, {type_name})"
 
             return super().datatype_sql(expression)
 
@@ -1741,3 +1840,25 @@ class SingleStore(MySQL):
 
             self.unsupported("STANDARD_HASH function is not supported in SingleStore")
             return self.func("SHA", expression.this)
+
+        @unsupported_args("is_database", "exists", "cluster", "identity", "option", "partition")
+        def truncatetable_sql(self, expression: exp.TruncateTable) -> str:
+            statements = []
+            for expression in expression.expressions:
+                statements.append(f"TRUNCATE {self.sql(expression)}")
+
+            return "; ".join(statements)
+
+        @unsupported_args("exists")
+        def renamecolumn_sql(self, expression: exp.RenameColumn) -> str:
+            old_column = self.sql(expression, "this")
+            new_column = self.sql(expression, "to")
+            return f"CHANGE {old_column} {new_column}"
+
+        @unsupported_args("drop", "comment", "allow_null", "visible", "using")
+        def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
+            alter = super().altercolumn_sql(expression)
+
+            collate = self.sql(expression, "collate")
+            collate = f" COLLATE {collate}" if collate else ""
+            return f"{alter}{collate}"

{sqlglot-27.13.2 → sqlglot-27.14.0}/sqlglot/dialects/snowflake.py

@@ -32,6 +32,7 @@ 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
 
@@ -482,6 +483,15 @@ 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)
+
+    return expression
+
+
 class Snowflake(Dialect):
     # https://docs.snowflake.com/en/sql-reference/identifiers-syntax
     NORMALIZATION_STRATEGY = NormalizationStrategy.UPPERCASE
@@ -500,9 +510,17 @@ class Snowflake(Dialect):
         **Dialect.ANNOTATORS,
         **{
             expr_type: lambda self, e: self._annotate_by_args(e, "this")
-            for expr_type in (exp.Reverse,)
+            for expr_type in (
+                exp.Left,
+                exp.Right,
+                exp.Substring,
+            )
         },
         exp.ConcatWs: lambda self, e: self._annotate_by_args(e, "expressions"),
+        exp.Length: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.INT),
+        exp.Replace: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
+        exp.Reverse: _annotate_reverse,
+        exp.Space: lambda self, e: self._annotate_with_type(e, exp.DataType.Type.VARCHAR),
     }
 
     TIME_MAPPING = {
@@ -664,7 +682,8 @@ class Snowflake(Dialect):
             "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_TZ": _build_datetime("TO_TIMESTAMP_TZ", exp.DataType.Type.TIMESTAMPTZ),
-            "TO_VARCHAR": exp.ToChar.from_arg_list,
+            "TO_VARCHAR": build_timetostr_or_tochar,
+            "TO_JSON": exp.JSONFormat.from_arg_list,
             "VECTOR_L2_DISTANCE": exp.EuclideanDistance.from_arg_list,
             "ZEROIFNULL": _build_if_from_zeroifnull,
         }
@@ -1273,6 +1292,7 @@ class Snowflake(Dialect):
             exp.ParseJSON: lambda self, e: self.func(
                 "TRY_PARSE_JSON" if e.args.get("safe") else "PARSE_JSON", e.this
             ),
+            exp.JSONFormat: rename_func("TO_JSON"),
             exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
             exp.PercentileCont: transforms.preprocess(
                 [transforms.add_within_group_for_percentiles]
@@ -1297,6 +1317,8 @@ class Snowflake(Dialect):
                 ]
             ),
             exp.SHA: rename_func("SHA1"),
+            exp.MD5Digest: rename_func("MD5_BINARY"),
+            exp.LowerHex: rename_func("TO_CHAR"),
             exp.SortArray: rename_func("ARRAY_SORT"),
             exp.StarMap: rename_func("OBJECT_CONSTRUCT"),
             exp.StartsWith: rename_func("STARTSWITH"),
@@ -1344,9 +1366,10 @@ class Snowflake(Dialect):
 
         TYPE_MAPPING = {
             **generator.Generator.TYPE_MAPPING,
+            exp.DataType.Type.BIGDECIMAL: "DOUBLE",
             exp.DataType.Type.NESTED: "OBJECT",
             exp.DataType.Type.STRUCT: "OBJECT",
-            exp.DataType.Type.BIGDECIMAL: "DOUBLE",
+            exp.DataType.Type.TEXT: "VARCHAR",
         }
 
         TOKEN_MAPPING = {

{sqlglot-27.13.2 → sqlglot-27.14.0}/sqlglot/dialects/sqlite.py

@@ -110,6 +110,7 @@ class SQLite(Dialect):
         STRING_ALIASES = True
         ALTER_RENAME_REQUIRES_COLUMN = False
         JOINS_HAVE_EQUAL_PRECEDENCE = True
+        ADD_JOIN_ON_TRUE = True
 
         FUNCTIONS = {
             **parser.Parser.FUNCTIONS,

{sqlglot-27.13.2 → sqlglot-27.14.0}/sqlglot/expressions.py

@@ -134,6 +134,11 @@ class Expression(metaclass=_Expression):
 
         return hash((self.__class__, self.hashable_args))
 
+    def __reduce__(self) -> t.Tuple[t.Callable, t.Tuple[t.Dict[str, t.Any]]]:
+        from sqlglot.serde import dump, load
+
+        return (load, (dump(self),))
+
     @property
     def this(self) -> t.Any:
         """
@@ -1646,6 +1651,12 @@ class Show(Expression):
         "position": False,
         "types": False,
         "privileges": False,
+        "for_table": False,
+        "for_group": False,
+        "for_user": False,
+        "for_role": False,
+        "into_outfile": False,
+        "json": False,
     }
 
 
@@ -2197,7 +2208,7 @@ class Copy(DML):
     arg_types = {
         "this": True,
         "kind": True,
-        "files": True,
+        "files": False,
         "credentials": False,
         "format": False,
         "params": False,
@@ -6694,11 +6705,26 @@ class JSONBContains(Binary, Func):
     _sql_names = ["JSONB_CONTAINS"]
 
 
+# https://www.postgresql.org/docs/9.5/functions-json.html
+class JSONBContainsAnyTopKeys(Binary, Func):
+    pass
+
+
+# https://www.postgresql.org/docs/9.5/functions-json.html
+class JSONBContainsAllTopKeys(Binary, Func):
+    pass
+
+
 class JSONBExists(Func):
     arg_types = {"this": True, "path": True}
     _sql_names = ["JSONB_EXISTS"]
 
 
+# https://www.postgresql.org/docs/9.5/functions-json.html
+class JSONBDeleteAtPath(Binary, Func):
+    pass
+
+
 class JSONExtract(Binary, Func):
     arg_types = {
         "this": True,
@@ -6963,6 +6989,11 @@ class Predict(Func):
     arg_types = {"this": True, "expression": True, "params_struct": False}
 
 
+# https://cloud.google.com/bigquery/docs/reference/standard-sql/bigqueryml-syntax-translate#mltranslate_function
+class MLTranslate(Func):
+    arg_types = {"this": True, "expression": True, "params_struct": True}
+
+
 # https://cloud.google.com/bigquery/docs/reference/standard-sql/bigqueryml-syntax-feature-time
 class FeaturesAtTime(Func):
     arg_types = {"this": True, "time": False, "num_rows": False, "ignore_feature_nulls": False}
@@ -6973,6 +7004,10 @@ class GenerateEmbedding(Func):
     arg_types = {"this": True, "expression": True, "params_struct": False}
 
 
+class MLForecast(Func):
+    arg_types = {"this": True, "expression": False, "params_struct": False}
+
+
 # https://cloud.google.com/bigquery/docs/reference/standard-sql/search_functions#vector_search
 class VectorSearch(Func):
     arg_types = {