sqlglot 27.13.1__py3-none-any.whl → 27.14.0__py3-none-any.whl

sqlglot/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '27.13.1'
-__version_tuple__ = version_tuple = (27, 13, 1)
+__version__ = version = '27.14.0'
+__version_tuple__ = version_tuple = (27, 14, 0)
 
 __commit_id__ = commit_id = None

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/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/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/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/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/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/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/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/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/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/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,
         }
@@ -1161,7 +1180,6 @@ class Snowflake(Dialect):
             "RM": TokenType.COMMAND,
             "SAMPLE": TokenType.TABLE_SAMPLE,
             "SEMANTIC VIEW": TokenType.SEMANTIC_VIEW,
-            "SESSION": TokenType.SESSION,
             "SQL_DOUBLE": TokenType.DOUBLE,
             "SQL_VARCHAR": TokenType.VARCHAR,
             "STAGE": TokenType.STAGE,
@@ -1274,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]
@@ -1298,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"),
@@ -1345,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/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/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 = {

sqlglot/generator.py

@@ -160,6 +160,9 @@ class Generator(metaclass=_Generator):
         exp.Intersect: lambda self, e: self.set_operations(e),
         exp.IntervalSpan: lambda self, e: f"{self.sql(e, 'this')} TO {self.sql(e, 'expression')}",
         exp.Int64: lambda self, e: self.sql(exp.cast(e.this, exp.DataType.Type.BIGINT)),
+        exp.JSONBContainsAnyTopKeys: lambda self, e: self.binary(e, "?|"),
+        exp.JSONBContainsAllTopKeys: lambda self, e: self.binary(e, "?&"),
+        exp.JSONBDeleteAtPath: lambda self, e: self.binary(e, "#-"),
         exp.LanguageProperty: lambda self, e: self.naked_property(e),
         exp.LocationProperty: lambda self, e: self.naked_property(e),
         exp.LogProperty: lambda _, e: f"{'NO ' if e.args.get('no') else ''}LOG",
@@ -4214,21 +4217,31 @@ class Generator(metaclass=_Generator):
     def opclass_sql(self, expression: exp.Opclass) -> str:
         return f"{self.sql(expression, 'this')} {self.sql(expression, 'expression')}"
 
-    def predict_sql(self, expression: exp.Predict) -> str:
+    def _ml_sql(self, expression: exp.Func, name: str) -> str:
         model = self.sql(expression, "this")
         model = f"MODEL {model}"
-        table = self.sql(expression, "expression")
-        table = f"TABLE {table}" if not isinstance(expression.expression, exp.Subquery) else table
-        parameters = self.sql(expression, "params_struct")
-        return self.func("PREDICT", model, table, parameters or None)
+        expr = expression.expression
+        if expr:
+            expr_sql = self.sql(expression, "expression")
+            expr_sql = f"TABLE {expr_sql}" if not isinstance(expr, exp.Subquery) else expr_sql
+        else:
+            expr_sql = None
+
+        parameters = self.sql(expression, "params_struct") or None
+
+        return self.func(name, model, expr_sql, parameters)
+
+    def predict_sql(self, expression: exp.Predict) -> str:
+        return self._ml_sql(expression, "PREDICT")
 
     def generateembedding_sql(self, expression: exp.GenerateEmbedding) -> str:
-        model = self.sql(expression, "this")
-        model = f"MODEL {model}"
-        table = self.sql(expression, "expression")
-        table = f"TABLE {table}" if not isinstance(expression.expression, exp.Subquery) else table
-        parameters = self.sql(expression, "params_struct")
-        return self.func("GENERATE_EMBEDDING", model, table, parameters or None)
+        return self._ml_sql(expression, "GENERATE_EMBEDDING")
+
+    def mltranslate_sql(self, expression: exp.MLTranslate) -> str:
+        return self._ml_sql(expression, "TRANSLATE")
+
+    def mlforecast_sql(self, expression: exp.MLForecast) -> str:
+        return self._ml_sql(expression, "FORECAST")
 
     def featuresattime_sql(self, expression: exp.FeaturesAtTime) -> str:
         this_sql = self.sql(expression, "this")
@@ -4579,8 +4592,8 @@ class Generator(metaclass=_Generator):
 
         credentials = self.sql(expression, "credentials")
         credentials = self.seg(credentials) if credentials else ""
-        kind = self.seg("FROM" if expression.args.get("kind") else "TO")
         files = self.expressions(expression, key="files", flat=True)
+        kind = self.seg("FROM" if expression.args.get("kind") else "TO") if files else ""
 
         sep = ", " if self.dialect.COPY_PARAMS_ARE_CSV else " "
         params = self.expressions(
@@ -4596,7 +4609,7 @@ class Generator(metaclass=_Generator):
         if params:
             if self.COPY_PARAMS_ARE_WRAPPED:
                 params = f" WITH ({params})"
-            elif not self.pretty:
+            elif not self.pretty and (files or credentials):
                 params = f" {params}"
 
         return f"COPY{this}{kind} {files}{credentials}{params}"

sqlglot/optimizer/annotate_types.py

@@ -193,6 +193,12 @@ class TypeAnnotator(metaclass=_TypeAnnotator):
         # Caches the ids of annotated sub-Expressions, to ensure we only visit them once
         self._visited: t.Set[int] = set()
 
+        # Caches NULL-annotated expressions to set them to UNKNOWN after type inference is completed
+        self._null_expressions: t.Dict[int, exp.Expression] = {}
+
+        # Databricks and Spark ≥v3 actually support NULL (i.e., VOID) as a type
+        self._supports_null_type = schema.dialect in ("databricks", "spark")
+
         # Maps an exp.SetOperation's id (e.g. UNION) to its projection types. This is computed if the
         # exp.SetOperation is the expression of a scope source, as selecting from it multiple times
         # would reprocess the entire subtree to coerce the types of its operands' projections
@@ -201,13 +207,33 @@ class TypeAnnotator(metaclass=_TypeAnnotator):
     def _set_type(
         self, expression: exp.Expression, target_type: t.Optional[exp.DataType | exp.DataType.Type]
     ) -> None:
+        prev_type = expression.type
+        expression_id = id(expression)
+
         expression.type = target_type or exp.DataType.Type.UNKNOWN  # type: ignore
-        self._visited.add(id(expression))
+        self._visited.add(expression_id)
+
+        if (
+            not self._supports_null_type
+            and t.cast(exp.DataType, expression.type).this == exp.DataType.Type.NULL
+        ):
+            self._null_expressions[expression_id] = expression
+        elif prev_type and t.cast(exp.DataType, prev_type).this == exp.DataType.Type.NULL:
+            self._null_expressions.pop(expression_id, None)
 
     def annotate(self, expression: E) -> E:
         for scope in traverse_scope(expression):
             self.annotate_scope(scope)
-        return self._maybe_annotate(expression)  # This takes care of non-traversable expressions
+
+        # This takes care of non-traversable expressions
+        expression = self._maybe_annotate(expression)
+
+        # Replace NULL type with UNKNOWN, since the former is not an actual type;
+        # it is mostly used to aid type coercion, e.g. in query set operations.
+        for expr in self._null_expressions.values():
+            expr.type = exp.DataType.Type.UNKNOWN
+
+        return expression
 
     def annotate_scope(self, scope: Scope) -> None:
         selects = {}

sqlglot/parser.py

@@ -569,6 +569,7 @@ class Parser(metaclass=_Parser):
         TokenType.USE,
         TokenType.VOLATILE,
         TokenType.WINDOW,
+        *ALTERABLES,
         *CREATABLES,
         *SUBQUERY_PREDICATES,
         *TYPE_TOKENS,
@@ -941,6 +942,9 @@ class Parser(metaclass=_Parser):
         TokenType.RLIKE: binary_range_parser(exp.RegexpLike),
         TokenType.SIMILAR_TO: binary_range_parser(exp.SimilarTo),
         TokenType.FOR: lambda self, this: self._parse_comprehension(this),
+        TokenType.QMARK_AMP: binary_range_parser(exp.JSONBContainsAllTopKeys),
+        TokenType.QMARK_PIPE: binary_range_parser(exp.JSONBContainsAnyTopKeys),
+        TokenType.HASH_DASH: binary_range_parser(exp.JSONBDeleteAtPath),
     }
 
     PIPE_SYNTAX_TRANSFORM_PARSERS = {
@@ -1554,6 +1558,10 @@ class Parser(metaclass=_Parser):
     # is true for Snowflake but not for BigQuery which can also process strings
     JSON_EXTRACT_REQUIRES_JSON_EXPRESSION = False
 
+    # Dialects like Databricks support JOINS without join criteria
+    # Adding an ON TRUE, makes transpilation semantically correct for other dialects
+    ADD_JOIN_ON_TRUE = False
+
     __slots__ = (
         "error_level",
         "error_message_context",
@@ -3204,9 +3212,10 @@ class Parser(metaclass=_Parser):
         elif self._match(TokenType.FROM):
             from_ = self._parse_from(skip_from_token=True, consume_pipe=True)
             # Support parentheses for duckdb FROM-first syntax
-            select = self._parse_select()
+            select = self._parse_select(from_=from_)
             if select:
-                select.set("from", from_)
+                if not select.args.get("from"):
+                    select.set("from", from_)
                 this = select
             else:
                 this = exp.select("*").from_(t.cast(exp.From, from_))
@@ -3234,6 +3243,7 @@ class Parser(metaclass=_Parser):
         parse_subquery_alias: bool = True,
         parse_set_operation: bool = True,
         consume_pipe: bool = True,
+        from_: t.Optional[exp.From] = None,
     ) -> t.Optional[exp.Expression]:
         query = self._parse_select_query(
             nested=nested,
@@ -3242,13 +3252,12 @@ class Parser(metaclass=_Parser):
             parse_set_operation=parse_set_operation,
         )
 
-        if (
-            consume_pipe
-            and self._match(TokenType.PIPE_GT, advance=False)
-            and isinstance(query, exp.Query)
-        ):
-            query = self._parse_pipe_syntax_query(query)
-            query = query.subquery(copy=False) if query and table else query
+        if consume_pipe and self._match(TokenType.PIPE_GT, advance=False):
+            if not query and from_:
+                query = exp.select("*").from_(from_)
+            if isinstance(query, exp.Query):
+                query = self._parse_pipe_syntax_query(query)
+                query = query.subquery(copy=False) if query and table else query
 
         return query
 
@@ -3875,6 +3884,16 @@ class Parser(metaclass=_Parser):
 
         comments = [c for token in (method, side, kind) if token for c in token.comments]
         comments = (join_comments or []) + comments
+
+        if (
+            self.ADD_JOIN_ON_TRUE
+            and not kwargs.get("on")
+            and not kwargs.get("using")
+            and not kwargs.get("method")
+            and kwargs.get("kind") in (None, "INNER", "OUTER")
+        ):
+            kwargs["on"] = exp.true()
+
         return self.expression(exp.Join, comments=comments, **kwargs)
 
     def _parse_opclass(self) -> t.Optional[exp.Expression]:
@@ -4406,6 +4425,8 @@ class Parser(metaclass=_Parser):
     def _parse_pivot_aggregation(self) -> t.Optional[exp.Expression]:
         func = self._parse_function()
         if not func:
+            if self._prev and self._prev.token_type == TokenType.COMMA:
+                return None
             self.raise_error("Expecting an aggregation function in PIVOT")
 
         return self._parse_alias(func)
@@ -5395,7 +5416,7 @@ class Parser(metaclass=_Parser):
 
                 # https://docs.snowflake.com/en/sql-reference/data-types-vector
                 if type_token == TokenType.VECTOR and len(expressions) == 2:
-                    expressions[0] = exp.DataType.build(expressions[0].name, dialect=self.dialect)
+                    expressions = self._parse_vector_expressions(expressions)
 
             if not self._match(TokenType.R_PAREN):
                 self._retreat(index)
@@ -5531,6 +5552,11 @@ class Parser(metaclass=_Parser):
 
         return this
 
+    def _parse_vector_expressions(
+        self, expressions: t.List[exp.Expression]
+    ) -> t.List[exp.Expression]:
+        return [exp.DataType.build(expressions[0].name, dialect=self.dialect), *expressions[1:]]
+
     def _parse_struct_types(self, type_required: bool = False) -> t.Optional[exp.Expression]:
         index = self._index
 
@@ -5804,6 +5830,9 @@ class Parser(metaclass=_Parser):
 
         return func
 
+    def _parse_function_args(self, alias: bool = False) -> t.List[exp.Expression]:
+        return self._parse_csv(lambda: self._parse_lambda(alias=alias))
+
     def _parse_function_call(
         self,
         functions: t.Optional[t.Dict[str, t.Callable]] = None,
@@ -5868,7 +5897,7 @@ class Parser(metaclass=_Parser):
             known_function = function and not anonymous
 
             alias = not known_function or upper in self.FUNCTIONS_WITH_ALIASED_ARGS
-            args = self._parse_csv(lambda: self._parse_lambda(alias=alias))
+            args = self._parse_function_args(alias)
 
             post_func_comments = self._curr and self._curr.comments
             if known_function and post_func_comments:
@@ -8369,6 +8398,13 @@ class Parser(metaclass=_Parser):
         kind = self._match(TokenType.FROM) or not self._match_text_seq("TO")
 
         files = self._parse_csv(self._parse_file_location)
+        if self._match(TokenType.EQ, advance=False):
+            # Backtrack one token since we've consumed the lhs of a parameter assignment here.
+            # This can happen for Snowflake dialect. Instead, we'd like to parse the parameter
+            # list via `_parse_wrapped(..)` below.
+            self._advance(-1)
+            files = []
+
         credentials = self._parse_credentials()
 
         self._match_text_seq("WITH")

sqlglot/serde.py

@@ -4,65 +4,115 @@ import typing as t
 
 from sqlglot import expressions as exp
 
-if t.TYPE_CHECKING:
-    JSON = t.Union[dict, list, str, float, int, bool, None]
-    Node = t.Union[t.List["Node"], exp.DataType.Type, exp.Expression, JSON]
 
-
-def dump(node: Node) -> JSON:
+def dump(expr: exp.Expression) -> t.Dict[str, t.Any]:
     """
-    Recursively dump an AST into a JSON-serializable dict.
+    Dump an Expression into a JSON serializable dict.
     """
-    if isinstance(node, list):
-        return [dump(i) for i in node]
-    if isinstance(node, exp.DataType.Type):
-        return {
-            "class": "DataType.Type",
-            "value": node.value,
-        }
-    if isinstance(node, exp.Expression):
+
+    root: t.Dict[str, t.Any] = {}
+    stack = [(expr, root)]
+
+    while stack:
+        node, payload = stack.pop()
+
         klass = node.__class__.__qualname__
+
         if node.__class__.__module__ != exp.__name__:
             klass = f"{node.__module__}.{klass}"
-        obj: t.Dict = {
-            "class": klass,
-            "args": {k: dump(v) for k, v in node.args.items() if v is not None and v != []},
-        }
+
+        payload["class"] = klass
+
         if node.type:
-            obj["type"] = dump(node.type)
+            payload["type"] = dump(node.type)
         if node.comments:
-            obj["comments"] = node.comments
+            payload["comments"] = node.comments
         if node._meta is not None:
-            obj["meta"] = node._meta
+            payload["meta"] = node._meta
+        if node.args:
+            args: t.Dict[str, t.Any] = {}
+            payload["args"] = args
+
+            for k, vs in node.args.items():
+                if vs is None or vs == []:
+                    continue
+                if hasattr(vs, "parent"):
+                    args[k] = {}
+                    stack.append((vs, args[k]))
+                elif type(vs) is list:
+                    expressions: t.List[t.Any] = []
+                    args[k] = expressions
 
-        return obj
-    return node
+                    for v in vs:
+                        if hasattr(v, "parent"):
+                            expressions.append({})
+                            stack.append((v, expressions[-1]))
+                        else:
+                            expressions.append(v)
+                elif isinstance(vs, exp.DataType.Type):
+                    args[k] = {"class": "DataType.Type", "value": vs.value}
+                else:
+                    args[k] = vs
 
+    return root
 
-def load(obj: JSON) -> Node:
+
+@t.overload
+def load(expression: None) -> None: ...
+
+
+@t.overload
+def load(expression: t.Dict[str, t.Any]) -> exp.Expression: ...
+
+
+def load(expression):
     """
-    Recursively load a dict (as returned by `dump`) into an AST.
+    Load a dict generated by dump into an Expression.
     """
-    if isinstance(obj, list):
-        return [load(i) for i in obj]
-    if isinstance(obj, dict):
-        class_name = obj["class"]
+    if expression is None:
+        return None
+
+    root = _load(expression)
+    stack = [(root, expression.get("args"))]
+
+    while stack:
+        obj, args = stack.pop()
+
+        if args:
+            for k, vs in args.items():
+                if isinstance(vs, list):
+                    array = []
+                    for v in vs:
+                        if isinstance(v, dict):
+                            child = _load(v)
+                            array.append(child)
+                            stack.append((child, v.get("args")))
+                        else:
+                            array.append(v)
+                    obj.set(k, array)
+                elif isinstance(vs, dict):
+                    child = _load(vs)
+                    stack.append((child, vs.get("args")))
+                    obj.set(k, child)
+                else:
+                    obj.set(k, vs)
+    return root
 
-        if class_name == "DataType.Type":
-            return exp.DataType.Type(obj["value"])
 
-        if "." in class_name:
-            module_path, class_name = class_name.rsplit(".", maxsplit=1)
-            module = __import__(module_path, fromlist=[class_name])
-        else:
-            module = exp
+def _load(payload: t.Dict[str, t.Any]) -> exp.Expression | exp.DataType.Type:
+    class_name = payload["class"]
 
-        klass = getattr(module, class_name)
+    if class_name == "DataType.Type":
+        return exp.DataType.Type(payload["value"])
 
-        expression = klass(**{k: load(v) for k, v in obj["args"].items()})
-        expression.type = t.cast(exp.DataType, load(obj.get("type")))
-        expression.comments = obj.get("comments")
-        expression._meta = obj.get("meta")
+    if "." in class_name:
+        module_path, class_name = class_name.rsplit(".", maxsplit=1)
+        module = __import__(module_path, fromlist=[class_name])
+    else:
+        module = exp
 
-        return expression
-    return obj
+    expression = getattr(module, class_name)()
+    expression.type = load(payload.get("type"))
+    expression.comments = payload.get("comments")
+    expression._meta = payload.get("meta")
+    return expression

sqlglot/tokens.py

@@ -85,6 +85,9 @@ class TokenType(AutoName):
     DAMP = auto()
     XOR = auto()
     DSTAR = auto()
+    QMARK_AMP = auto()
+    QMARK_PIPE = auto()
+    HASH_DASH = auto()
 
     URI_START = auto()
 

{sqlglot-27.13.1.dist-info → sqlglot-27.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglot
-Version: 27.13.1
+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.1.dist-info → sqlglot-27.14.0.dist-info}/RECORD

@@ -1,51 +1,51 @@
 sqlglot/__init__.py,sha256=za08rtdPh2v7dOpGdNomttlIVGgTrKja7rPd6sQwaTg,5391
 sqlglot/__main__.py,sha256=022c173KqxsiABWTEpUIq_tJUxuNiW7a7ABsxBXqvu8,2069
 sqlglot/_typing.py,sha256=-1HPyr3w5COlSJWqlgt8jhFk2dyMvBuvVBqIX1wyVCM,642
-sqlglot/_version.py,sha256=ou5bykwli5rw5_qblbMze4DFs75loRI8NxexhmePC64,708
+sqlglot/_version.py,sha256=dO3zbTXGDFSvRTydZPKWrc0n8_OL2jG2s0_3yJeMyuY,708
 sqlglot/diff.py,sha256=PtOllQMQa1Sw1-V2Y8eypmDqGujXYPaTOp_WLsWkAWk,17314
 sqlglot/errors.py,sha256=QNKMr-pzLUDR-tuMmn_GK6iMHUIVdb_YSJ_BhGEvuso,2126
-sqlglot/expressions.py,sha256=oestq-dQt-OC2XLgG0B-I3cDgg7DptuXmcUW7_uP6aQ,253755
-sqlglot/generator.py,sha256=cO2HdHWKlL8Y7zs81hSsR-mFcy7U5x0Wd3A27jkn3lk,224692
+sqlglot/expressions.py,sha256=LteUkI-eNj_xG4AvHTGuzqcZb2elWXygT5dR1FcxudI,254734
+sqlglot/generator.py,sha256=5A8fDNIE6u_SuTiSLR4tLDfmoA5LRG9nHIEMqVutaMg,225102
 sqlglot/helper.py,sha256=9nZjFVRBtMKFC3EdzpDQ6jkazFO19po6BF8xHiNGZIo,15111
 sqlglot/jsonpath.py,sha256=SQgaxzaEYBN7At9dkTK4N1Spk6xHxvHL6QtCIP6iM30,7905
 sqlglot/lineage.py,sha256=Qj5ykuDNcATppb9vOjoIKBqRVLbu3OMPiZk9f3iyv40,15312
-sqlglot/parser.py,sha256=6QMiFaVbl7LJX-YMaZvJT_g28de2k3G5V-uDAx3zWTg,333268
+sqlglot/parser.py,sha256=YECjuYjATlMIqgHyEyRDjG7Xm0Of2fHfsm2UgLCYNP0,334925
 sqlglot/planner.py,sha256=ql7Li-bWJRcyXzNaZy_n6bQ6B2ZfunEIB8Ztv2xaxq4,14634
 sqlglot/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlglot/schema.py,sha256=13H2qKQs27EKdTpDLOvcNnSTDAUbYNKjWtJs4aQCSOA,20509
-sqlglot/serde.py,sha256=DQVJ95WrIvhYfe02Ytb4NQug2aMwDCEwpMBW1LKDqzE,2031
+sqlglot/serde.py,sha256=MFPE_7FgJx_kAZZFoaobj38jCjT6jfGghJUjzZBEUMs,3426
 sqlglot/time.py,sha256=Q62gv6kL40OiRBF6BMESxKJcMVn7ZLNw7sv8H34z5FI,18400
-sqlglot/tokens.py,sha256=GuRPOipxixWdEJDxIat9ZLPAn3JhQ2cP94qvOelXogU,49076
+sqlglot/tokens.py,sha256=_Esqa2AB1PI7o7EUkupGUQYCvriE71O8J7BQiYySHC0,49146
 sqlglot/transforms.py,sha256=utNDsCBsA7hPUK3-aby3DDgiY_XVMAKQqeoLm1EyihI,41218
 sqlglot/trie.py,sha256=v27uXMrHfqrXlJ6GmeTSMovsB_3o0ctnlKhdNt7W6fI,2245
 sqlglot/dialects/__init__.py,sha256=e3K2NHrZO7oXfBzEpRsvgWAgJ_UCEyg7SlUCRqvnPj4,3799
 sqlglot/dialects/athena.py,sha256=ofArmayYLev4qZQ15GM8mevG04qqR5WGFb2ZcuYm6x4,10966
-sqlglot/dialects/bigquery.py,sha256=IO5u1sdT0wzl76_z3FVm8FgtVnnMBrFPab-HhxuxROs,72078
-sqlglot/dialects/clickhouse.py,sha256=YLY8s7oCfdCoD0X2iOIltivXXjtT_nJdb3931P0TDeU,58553
+sqlglot/dialects/bigquery.py,sha256=Oz9_pYUhVHBjHschYvar4V9hgz8KywokEV0y4hNXi7w,72371
+sqlglot/dialects/clickhouse.py,sha256=OzcDAS7pWs889gu0aLYn_HIjTLiPRjGFG61p6-84stE,58574
 sqlglot/dialects/databricks.py,sha256=H4QTq7gg6tJylKc_YWsGp6049KydoI_wlQUHM7iCJtI,4753
-sqlglot/dialects/dialect.py,sha256=MFP2WHesP-wf2HXub8s0_XyeUnjXCk8QNcqn5AIhARw,73361
+sqlglot/dialects/dialect.py,sha256=BU4-x1d8tRCSAfdpeP5b86me0wXfgpcEPdyk27wLgg4,73293
 sqlglot/dialects/doris.py,sha256=CFnF955Oav3IjZWA80ickOI8tPpCjxk7BN5R4Z6pA1U,25263
 sqlglot/dialects/dremio.py,sha256=nOMxu_4xVKSOmMGNSwdxXSPc243cNbbpb-xXzYdgdeg,8460
 sqlglot/dialects/drill.py,sha256=FOh7_KjPx_77pv0DiHKZog0CcmzqeF9_PEmGnJ1ESSM,5825
 sqlglot/dialects/druid.py,sha256=kh3snZtneehNOWqs3XcPjsrhNaRbkCQ8E4hHbWJ1fHM,690
-sqlglot/dialects/duckdb.py,sha256=ANzn5L5KS5pe9hn81Ta_4h5ngdPxMS1k_LdMuYGiff8,52470
+sqlglot/dialects/duckdb.py,sha256=ZVXloJqjz_LiMFJ80v14P01hAwerje5NT2FeQdzAaqc,53023
 sqlglot/dialects/dune.py,sha256=gALut-fFfN2qMsr8LvZ1NQK3F3W9z2f4PwMvTMXVVVg,375
 sqlglot/dialects/exasol.py,sha256=ay3g_VyT5WvHTgNyJuCQu0nBt4bpllLZ9IdMBizEgYM,15761
-sqlglot/dialects/fabric.py,sha256=4Sng2ZhQSaf6eK3ituR9DqDZERaVwYS_UfdpusjsISg,10220
-sqlglot/dialects/hive.py,sha256=zFr6WmNZXw5C0m3nFc9ynrbzk8Wtb5gyzmJ0tPlMge8,32014
+sqlglot/dialects/fabric.py,sha256=BdkvzM8s-m5DIdBwdjEYskp32ub7aHCAex_xlhQn92I,10222
+sqlglot/dialects/hive.py,sha256=UGIkXjMCk5a9ndUXQtvfG560oi3emdpqOYLQCmGabBk,32046
 sqlglot/dialects/materialize.py,sha256=LD2q1kTRrCwkIu1BfoBvnjTGbupDtoQ8JQMDCIYAXHg,3533
-sqlglot/dialects/mysql.py,sha256=pAIWuwvirUrFbJE06UiST9iyiA4-IkA1sGiMgkeo1DY,47884
+sqlglot/dialects/mysql.py,sha256=YuLyZBrEw4qSacd_1LGLJX4n-P99alnhQmANBlSFT4o,49408
 sqlglot/dialects/oracle.py,sha256=zWPCpzGiTlgCJ5E6FjfX3Rszjcw4SnHg6xeVboMYIyo,15972
-sqlglot/dialects/postgres.py,sha256=NsaNBKUrqzb3bjVi16IBlYi8FPJnHRTl46lQX1GDNzw,33849
+sqlglot/dialects/postgres.py,sha256=Zr5b0Yl5yXDKANcvUtnRsWUXLkbeEBZjwzFDAGtuub0,34296
 sqlglot/dialects/presto.py,sha256=XVeYr2NP86x5enlRqI7MYR6le85_ucYg_BBRocGN3jM,33413
 sqlglot/dialects/prql.py,sha256=fwN-SPEGx-drwf1K0U2MByN-PkW3C_rOgQ3xeJeychg,7908
-sqlglot/dialects/redshift.py,sha256=_sQTom4CGozFDZXW9y6bHQcZ-KiQ7QJjjQqM5rVagSc,15889
+sqlglot/dialects/redshift.py,sha256=FIwtP3yEg-way9pa32kxCJc6IaFkHVIvgYKZA-Ilmi0,15919
 sqlglot/dialects/risingwave.py,sha256=BqWwW1iT_OIVMwfRamaww79snnBwIgCfr22Go-ggO68,3289
-sqlglot/dialects/singlestore.py,sha256=_42yJP-YYbHswIBCKO5qxP5Z_AVksLh3bMX394iivwQ,55764
-sqlglot/dialects/snowflake.py,sha256=xIftl1twnug9C-MW-jUncKskKVOwds3jpBvCDFmp5kM,72084
+sqlglot/dialects/singlestore.py,sha256=GJrMoUK366JsQZyS_L8oGVkMkiVty1tijy7zqWAJ6Ck,61290
+sqlglot/dialects/snowflake.py,sha256=mmBa0iHgBDSo9M508cdluWzEjvMbTotLRERS3-ybsVI,73091
 sqlglot/dialects/spark.py,sha256=PzyhkelDzbCMgJ3RVHD6yyzLIFp9NdZfwVas5IymowM,10147
 sqlglot/dialects/spark2.py,sha256=qz36FT9k4iuiqboRpyG4VpKGkPR0P2fifmqgZ9gNUEU,14851
-sqlglot/dialects/sqlite.py,sha256=UIQ66shIt2bQoLd7tYG4NVzh4HwCfERgAaLyukz8HjE,13231
+sqlglot/dialects/sqlite.py,sha256=zzXEbnaLjJeg6hPLHricjpfSkuf8tpXECnjcHtoqIbw,13263
 sqlglot/dialects/starrocks.py,sha256=2gav0PSNgRdAGXzawdznZliBpglJoQ0wBxPI7ZIMsRw,11314
 sqlglot/dialects/tableau.py,sha256=oIawDzUITxGCWaEMB8OaNMPWhbC3U-2y09pYPm4eazc,2190
 sqlglot/dialects/teradata.py,sha256=7LxCcRwP0Idd_OnCzA57NCdheVjHcKC2aFAKG5N49IU,18202
@@ -57,7 +57,7 @@ sqlglot/executor/env.py,sha256=tQhU5PpTBMcxgZIFddFqxWMNPtHN0vOOz72voncY3KY,8276
 sqlglot/executor/python.py,sha256=09GYRzrPn3lZGfDJY9pbONOvmYxsRyeSWjUiqkSRHGo,16661
 sqlglot/executor/table.py,sha256=xkuJlgLVNYUXsSUaX0zTcnFekldXLLU8LqDyjR5K9wY,4419
 sqlglot/optimizer/__init__.py,sha256=FdAvVz6rQLLkiiH21-SD4RxB5zS3WDeU-s03PZkJ-F4,343
-sqlglot/optimizer/annotate_types.py,sha256=MfxXNzYgxaqhv1yBmzuigWjc1oIw1ikZ_lXjcdT3RDc,25128
+sqlglot/optimizer/annotate_types.py,sha256=RuBjs-mnWjH-wa02UKPMPq-3ymjQ_X7_t7Vz9xNhNOA,26202
 sqlglot/optimizer/canonicalize.py,sha256=RJpUbWDudjknRMtO_Kf8MGZ5Hv1twpPWac2u5kpV4Vw,7719
 sqlglot/optimizer/eliminate_ctes.py,sha256=fUBM0RUnPrm2sYptEWBux98B7fcx7W-BM1zVqfgDz9c,1448
 sqlglot/optimizer/eliminate_joins.py,sha256=2iYtG93aJGxvURqm1BVPosrnnnQ_IXI14RcD4pM8eHc,5942
@@ -76,8 +76,8 @@ sqlglot/optimizer/qualify_tables.py,sha256=dA4ZazL7ShQh2JgBwpHuG-4c5lBw1TNzCnuN7
 sqlglot/optimizer/scope.py,sha256=UOTrbwqcTc5iRQf0WStgYWXpE24w6riZy-tJYA18yTw,31229
 sqlglot/optimizer/simplify.py,sha256=-_yus42OYwqjQ9a2TSGhtG2G0pSkInUry1z7hEMz2pY,51062
 sqlglot/optimizer/unnest_subqueries.py,sha256=kzWUVDlxs8z9nmRx-8U-pHXPtVZhEIwkKqmKhr2QLvc,10908
-sqlglot-27.13.1.dist-info/licenses/LICENSE,sha256=p1Yk0B4oa0l8Rh-_dYyy75d8spjPd_vTloXfz4FWxys,1065
-sqlglot-27.13.1.dist-info/METADATA,sha256=rnD1jn-fbRMKBZZGZWvzMgUuE3KzqbHgqXMzDSnwIcw,20682
-sqlglot-27.13.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sqlglot-27.13.1.dist-info/top_level.txt,sha256=5kRskCGA_gVADF9rSfSzPdLHXqvfMusDYeHePfNY2nQ,8
-sqlglot-27.13.1.dist-info/RECORD,,
+sqlglot-27.14.0.dist-info/licenses/LICENSE,sha256=p1Yk0B4oa0l8Rh-_dYyy75d8spjPd_vTloXfz4FWxys,1065
+sqlglot-27.14.0.dist-info/METADATA,sha256=BYDS9AxQRhQ_DsItPkMNCkZR3NfunsRSWM7kkNoPCDY,20682
+sqlglot-27.14.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sqlglot-27.14.0.dist-info/top_level.txt,sha256=5kRskCGA_gVADF9rSfSzPdLHXqvfMusDYeHePfNY2nQ,8
+sqlglot-27.14.0.dist-info/RECORD,,