sqlglot 27.14.0__py3-none-any.whl → 27.15.1__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.14.0'
-__version_tuple__ = version_tuple = (27, 14, 0)
+__version__ = version = '27.15.1'
+__version_tuple__ = version_tuple = (27, 15, 1)
 
 __commit_id__ = commit_id = None

sqlglot/dialects/bigquery.py

@@ -863,6 +863,9 @@ class BigQuery(Dialect):
             "TRANSLATE": lambda self: self._parse_translate(),
             "FEATURES_AT_TIME": lambda self: self._parse_features_at_time(),
             "GENERATE_EMBEDDING": lambda self: self._parse_ml(exp.GenerateEmbedding),
+            "GENERATE_TEXT_EMBEDDING": lambda self: self._parse_ml(
+                exp.GenerateEmbedding, is_text=True
+            ),
             "VECTOR_SEARCH": lambda self: self._parse_vector_search(),
             "FORECAST": lambda self: self._parse_ml(exp.MLForecast),
         }
@@ -894,8 +897,6 @@ class BigQuery(Dialect):
         RANGE_PARSERS = parser.Parser.RANGE_PARSERS.copy()
         RANGE_PARSERS.pop(TokenType.OVERLAPS)
 
-        NULL_TOKENS = {TokenType.NULL, TokenType.UNKNOWN}
-
         DASHED_TABLE_PART_FOLLOW_TOKENS = {TokenType.DOT, TokenType.L_PAREN, TokenType.R_PAREN}
 
         STATEMENT_PARSERS = {
@@ -1148,7 +1149,7 @@ class BigQuery(Dialect):
 
             return expr
 
-        def _parse_ml(self, expr_type: t.Type[E]) -> E:
+        def _parse_ml(self, expr_type: t.Type[E], **kwargs) -> E:
             self._match_text_seq("MODEL")
             this = self._parse_table()
 
@@ -1167,6 +1168,7 @@ class BigQuery(Dialect):
                 this=this,
                 expression=expression,
                 params_struct=self._parse_bitwise(),
+                **kwargs,
             )
 
         def _parse_translate(self) -> exp.Translate | exp.MLTranslate:

sqlglot/dialects/mysql.py

@@ -191,10 +191,8 @@ class MySQL(Dialect):
 
         KEYWORDS = {
             **tokens.Tokenizer.KEYWORDS,
-            "CHARSET": TokenType.CHARACTER_SET,
-            # The DESCRIBE and EXPLAIN statements are synonyms.
-            # https://dev.mysql.com/doc/refman/8.4/en/explain.html
             "BLOB": TokenType.BLOB,
+            "CHARSET": TokenType.CHARACTER_SET,
             "DISTINCTROW": TokenType.DISTINCT,
             "EXPLAIN": TokenType.DESCRIBE,
             "FORCE": TokenType.FORCE,
@@ -204,17 +202,19 @@ class MySQL(Dialect):
             "LONGBLOB": TokenType.LONGBLOB,
             "LONGTEXT": TokenType.LONGTEXT,
             "MEDIUMBLOB": TokenType.MEDIUMBLOB,
-            "TINYBLOB": TokenType.TINYBLOB,
-            "TINYTEXT": TokenType.TINYTEXT,
-            "MEDIUMTEXT": TokenType.MEDIUMTEXT,
             "MEDIUMINT": TokenType.MEDIUMINT,
+            "MEDIUMTEXT": TokenType.MEDIUMTEXT,
             "MEMBER OF": TokenType.MEMBER_OF,
+            "MOD": TokenType.MOD,
             "SEPARATOR": TokenType.SEPARATOR,
             "SERIAL": TokenType.SERIAL,
-            "START": TokenType.BEGIN,
             "SIGNED": TokenType.BIGINT,
             "SIGNED INTEGER": TokenType.BIGINT,
+            "SOUNDS LIKE": TokenType.SOUNDS_LIKE,
+            "START": TokenType.BEGIN,
             "TIMESTAMP": TokenType.TIMESTAMPTZ,
+            "TINYBLOB": TokenType.TINYBLOB,
+            "TINYTEXT": TokenType.TINYTEXT,
             "UNLOCK TABLES": TokenType.COMMAND,
             "UNSIGNED": TokenType.UBIGINT,
             "UNSIGNED INTEGER": TokenType.UBIGINT,
@@ -271,6 +271,7 @@ class MySQL(Dialect):
         FUNC_TOKENS = {
             *parser.Parser.FUNC_TOKENS,
             TokenType.DATABASE,
+            TokenType.MOD,
             TokenType.SCHEMA,
             TokenType.VALUES,
         }
@@ -292,6 +293,11 @@ class MySQL(Dialect):
 
         RANGE_PARSERS = {
             **parser.Parser.RANGE_PARSERS,
+            TokenType.SOUNDS_LIKE: lambda self, this: self.expression(
+                exp.EQ,
+                this=self.expression(exp.Soundex, this=this),
+                expression=self.expression(exp.Soundex, this=self._parse_term()),
+            ),
             TokenType.MEMBER_OF: lambda self, this: self.expression(
                 exp.JSONArrayContains,
                 this=this,
@@ -359,6 +365,7 @@ class MySQL(Dialect):
                 exp.Anonymous, this="VALUES", expressions=[self._parse_id_var()]
             ),
             "JSON_VALUE": lambda self: self._parse_json_value(),
+            "SUBSTR": lambda self: self._parse_substring(),
         }
 
         STATEMENT_PARSERS = {

sqlglot/dialects/postgres.py

@@ -424,6 +424,11 @@ class Postgres(Dialect):
         FUNCTION_PARSERS = {
             **parser.Parser.FUNCTION_PARSERS,
             "DATE_PART": lambda self: self._parse_date_part(),
+            "JSON_AGG": lambda self: self.expression(
+                exp.JSONArrayAgg,
+                this=self._parse_bitwise(),
+                order=self._parse_order(),
+            ),
             "JSONB_EXISTS": lambda self: self._parse_jsonb_exists(),
         }
 
@@ -608,6 +613,11 @@ class Postgres(Dialect):
                 self, e, func_name="STRING_AGG", within_group=False
             ),
             exp.IntDiv: rename_func("DIV"),
+            exp.JSONArrayAgg: lambda self, e: self.func(
+                "JSON_AGG",
+                self.sql(e, "this"),
+                suffix=f"{self.sql(e, 'order')})",
+            ),
             exp.JSONExtract: _json_extract_sql("JSON_EXTRACT_PATH", "->"),
             exp.JSONExtractScalar: _json_extract_sql("JSON_EXTRACT_PATH_TEXT", "->>"),
             exp.JSONBExtract: lambda self, e: self.binary(e, "#>"),

sqlglot/dialects/singlestore.py

@@ -527,6 +527,7 @@ class SingleStore(MySQL):
                 e.expression,
                 self.func("SUBSTRING", e.this, e.args.get("start") + e.args.get("length")),
             ),
+            exp.National: lambda self, e: self.national_sql(e, prefix=""),
             exp.Reduce: unsupported_args("finish")(
                 lambda self, e: self.func(
                     "REDUCE", e.args.get("initial"), e.this, e.args.get("merge")
@@ -1862,3 +1863,9 @@ class SingleStore(MySQL):
             collate = self.sql(expression, "collate")
             collate = f" COLLATE {collate}" if collate else ""
             return f"{alter}{collate}"
+
+        def computedcolumnconstraint_sql(self, expression: exp.ComputedColumnConstraint) -> str:
+            this = self.sql(expression, "this")
+            not_null = " NOT NULL" if expression.args.get("not_null") else ""
+            type = self.sql(expression, "data_type") or "AUTO"
+            return f"AS {this} PERSISTED {type}{not_null}"

sqlglot/dialects/snowflake.py

@@ -6,6 +6,7 @@ from sqlglot import exp, generator, jsonpath, parser, tokens, transforms
 from sqlglot.dialects.dialect import (
     Dialect,
     NormalizationStrategy,
+    annotate_with_type_lambda,
     build_timetostr_or_tochar,
     binary_from_function,
     build_default_decimal_type,
@@ -377,6 +378,7 @@ def _qualify_unnested_columns(expression: exp.Expression) -> exp.Expression:
 
         taken_source_names = set(scope.sources)
         column_source: t.Dict[str, exp.Identifier] = {}
+        unnest_to_identifier: t.Dict[exp.Unnest, exp.Identifier] = {}
 
         unnest_identifier: t.Optional[exp.Identifier] = None
         orig_expression = expression.copy()
@@ -429,6 +431,7 @@ def _qualify_unnested_columns(expression: exp.Expression) -> exp.Expression:
             if not isinstance(unnest_identifier, exp.Identifier):
                 return orig_expression
 
+            unnest_to_identifier[unnest] = unnest_identifier
             column_source.update({c.lower(): unnest_identifier for c in unnest_columns})
 
         for column in scope.columns:
@@ -442,6 +445,15 @@ def _qualify_unnested_columns(expression: exp.Expression) -> exp.Expression:
                 and len(scope.sources) == 1
                 and column.name.lower() != unnest_identifier.name.lower()
             ):
+                unnest_ancestor = column.find_ancestor(exp.Unnest, exp.Select)
+                ancestor_identifier = unnest_to_identifier.get(unnest_ancestor)
+                if (
+                    isinstance(unnest_ancestor, exp.Unnest)
+                    and ancestor_identifier
+                    and ancestor_identifier.name.lower() == unnest_identifier.name.lower()
+                ):
+                    continue
+
                 table = unnest_identifier
 
             column.set("table", table and table.copy())
@@ -506,8 +518,49 @@ class Snowflake(Dialect):
     ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN = False
     TRY_CAST_REQUIRES_STRING = True
 
+    TYPE_TO_EXPRESSIONS = {
+        **Dialect.TYPE_TO_EXPRESSIONS,
+        exp.DataType.Type.INT: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.INT],
+            exp.Length,
+        },
+        exp.DataType.Type.VARCHAR: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.VARCHAR],
+            exp.MD5,
+            exp.AIAgg,
+            exp.AISummarizeAgg,
+            exp.RegexpExtract,
+            exp.RegexpReplace,
+            exp.Repeat,
+            exp.Replace,
+            exp.SHA,
+            exp.SHA2,
+            exp.Space,
+            exp.Uuid,
+        },
+        exp.DataType.Type.BINARY: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.BINARY],
+            exp.MD5Digest,
+            exp.SHA1Digest,
+            exp.SHA2Digest,
+        },
+        exp.DataType.Type.BIGINT: {
+            *Dialect.TYPE_TO_EXPRESSIONS[exp.DataType.Type.BIGINT],
+            exp.MD5NumberLower64,
+            exp.MD5NumberUpper64,
+        },
+        exp.DataType.Type.ARRAY: {
+            exp.Split,
+        },
+    }
+
     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 (
@@ -517,10 +570,7 @@ class Snowflake(Dialect):
             )
         },
         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 = {
@@ -640,6 +690,10 @@ class Snowflake(Dialect):
             ),
             "HEX_DECODE_BINARY": exp.Unhex.from_arg_list,
             "IFF": exp.If.from_arg_list,
+            "MD5_HEX": exp.MD5.from_arg_list,
+            "MD5_BINARY": exp.MD5Digest.from_arg_list,
+            "MD5_NUMBER_LOWER64": exp.MD5NumberLower64.from_arg_list,
+            "MD5_NUMBER_UPPER64": exp.MD5NumberUpper64.from_arg_list,
             "LAST_DAY": lambda args: exp.LastDay(
                 this=seq_get(args, 0), unit=map_date_part(seq_get(args, 1))
             ),
@@ -647,12 +701,17 @@ class Snowflake(Dialect):
             "LENGTH": lambda args: exp.Length(this=seq_get(args, 0), binary=True),
             "NULLIFZERO": _build_if_from_nullifzero,
             "OBJECT_CONSTRUCT": _build_object_construct,
+            "OCTET_LENGTH": exp.ByteLength.from_arg_list,
             "REGEXP_EXTRACT_ALL": _build_regexp_extract(exp.RegexpExtractAll),
             "REGEXP_REPLACE": _build_regexp_replace,
             "REGEXP_SUBSTR": _build_regexp_extract(exp.RegexpExtract),
             "REGEXP_SUBSTR_ALL": _build_regexp_extract(exp.RegexpExtractAll),
             "REPLACE": build_replace_with_optional_replacement,
             "RLIKE": exp.RegexpLike.from_arg_list,
+            "SHA1_BINARY": exp.SHA1Digest.from_arg_list,
+            "SHA1_HEX": exp.SHA.from_arg_list,
+            "SHA2_BINARY": exp.SHA2Digest.from_arg_list,
+            "SHA2_HEX": exp.SHA2.from_arg_list,
             "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)),
             "TABLE": lambda args: exp.TableFromRows(this=seq_get(args, 0)),
             "TIMEADD": _build_date_time_add(exp.TimeAdd),
@@ -1318,6 +1377,8 @@ class Snowflake(Dialect):
             ),
             exp.SHA: rename_func("SHA1"),
             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.StarMap: rename_func("OBJECT_CONSTRUCT"),
@@ -1356,6 +1417,7 @@ class Snowflake(Dialect):
             exp.VarMap: lambda self, e: var_map_sql(self, e, "OBJECT_CONSTRUCT"),
             exp.WeekOfYear: rename_func("WEEKOFYEAR"),
             exp.Xor: rename_func("BOOLXOR"),
+            exp.ByteLength: rename_func("OCTET_LENGTH"),
         }
 
         SUPPORTED_JSON_PATH_PARTS = {

sqlglot/dialects/tsql.py

@@ -650,6 +650,16 @@ class TSQL(Dialect):
             "NEXT": lambda self: self._parse_next_value_for(),
         }
 
+        FUNCTION_PARSERS: t.Dict[str, t.Callable] = {
+            **parser.Parser.FUNCTION_PARSERS,
+            "JSON_ARRAYAGG": lambda self: self.expression(
+                exp.JSONArrayAgg,
+                this=self._parse_bitwise(),
+                order=self._parse_order(),
+                null_handling=self._parse_on_handling("NULL", "NULL", "ABSENT"),
+            ),
+        }
+
         # The DCOLON (::) operator serves as a scope resolution (exp.ScopeResolution) operator in T-SQL
         COLUMN_OPERATORS = {
             **parser.Parser.COLUMN_OPERATORS,

sqlglot/expressions.py

@@ -134,7 +134,7 @@ 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]]]:
+    def __reduce__(self) -> t.Tuple[t.Callable, t.Tuple[t.List[t.Dict[str, t.Any]]]]:
         from sqlglot.serde import dump, load
 
         return (load, (dump(self),))
@@ -264,7 +264,7 @@ class Expression(metaclass=_Expression):
         return self.type is not None and self.type.is_type(*dtypes)
 
     def is_leaf(self) -> bool:
-        return not any(isinstance(v, (Expression, list)) for v in self.args.values())
+        return not any(isinstance(v, (Expression, list)) and v for v in self.args.values())
 
     @property
     def meta(self) -> t.Dict[str, t.Any]:
@@ -2065,7 +2065,7 @@ class ProjectionPolicyColumnConstraint(ColumnConstraintKind):
 # computed column expression
 # https://learn.microsoft.com/en-us/sql/t-sql/statements/create-table-transact-sql?view=sql-server-ver16
 class ComputedColumnConstraint(ColumnConstraintKind):
-    arg_types = {"this": True, "persisted": False, "not_null": False}
+    arg_types = {"this": True, "persisted": False, "not_null": False, "data_type": False}
 
 
 class Constraint(Expression):
@@ -5766,6 +5766,15 @@ class ArrayUniqueAgg(AggFunc):
     pass
 
 
+class AIAgg(AggFunc):
+    arg_types = {"this": True, "expression": True}
+    _sql_names = ["AI_AGG"]
+
+
+class AISummarizeAgg(AggFunc):
+    _sql_names = ["AI_SUMMARIZE_AGG"]
+
+
 class ArrayAll(Func):
     arg_types = {"this": True, "expression": True}
 
@@ -6951,6 +6960,16 @@ class MD5Digest(Func):
     _sql_names = ["MD5_DIGEST"]
 
 
+# https://docs.snowflake.com/en/sql-reference/functions/md5_number_lower64
+class MD5NumberLower64(Func):
+    pass
+
+
+# https://docs.snowflake.com/en/sql-reference/functions/md5_number_upper64
+class MD5NumberUpper64(Func):
+    pass
+
+
 class Median(AggFunc):
     pass
 
@@ -7001,7 +7020,7 @@ class FeaturesAtTime(Func):
 
 # https://cloud.google.com/bigquery/docs/reference/standard-sql/bigqueryml-syntax-generate-embedding
 class GenerateEmbedding(Func):
-    arg_types = {"this": True, "expression": True, "params_struct": False}
+    arg_types = {"this": True, "expression": True, "params_struct": False, "is_text": False}
 
 
 class MLForecast(Func):
@@ -7201,6 +7220,16 @@ class SHA2(Func):
     arg_types = {"this": True, "length": False}
 
 
+# Represents the variant of the SHA1 function that returns a binary value
+class SHA1Digest(Func):
+    pass
+
+
+# Represents the variant of the SHA2 function that returns a binary value
+class SHA2Digest(Func):
+    arg_types = {"this": True, "length": False}
+
+
 class Sign(Func):
     _sql_names = ["SIGN", "SIGNUM"]
 

sqlglot/generator.py

@@ -4235,7 +4235,8 @@ class Generator(metaclass=_Generator):
         return self._ml_sql(expression, "PREDICT")
 
     def generateembedding_sql(self, expression: exp.GenerateEmbedding) -> str:
-        return self._ml_sql(expression, "GENERATE_EMBEDDING")
+        name = "GENERATE_TEXT_EMBEDDING" if expression.args.get("is_text") else "GENERATE_EMBEDDING"
+        return self._ml_sql(expression, name)
 
     def mltranslate_sql(self, expression: exp.MLTranslate) -> str:
         return self._ml_sql(expression, "TRANSLATE")

sqlglot/optimizer/annotate_types.py

@@ -593,14 +593,18 @@ class TypeAnnotator(metaclass=_TypeAnnotator):
     def _annotate_struct_value(
         self, expression: exp.Expression
     ) -> t.Optional[exp.DataType] | exp.ColumnDef:
-        alias = expression.args.get("alias")
-        if alias:
+        # Case: STRUCT(key AS value)
+        if alias := expression.args.get("alias"):
             return exp.ColumnDef(this=alias.copy(), kind=expression.type)
 
-        # Case: key = value or key := value
+        # Case: STRUCT(key = value) or STRUCT(key := value)
         if expression.expression:
             return exp.ColumnDef(this=expression.this.copy(), kind=expression.expression.type)
 
+        # Case: STRUCT(c)
+        if isinstance(expression, exp.Column):
+            return exp.ColumnDef(this=expression.this.copy(), kind=expression.type)
+
         return expression.type
 
     def _annotate_struct(self, expression: exp.Struct) -> exp.Struct:

sqlglot/optimizer/qualify_columns.py

@@ -351,11 +351,15 @@ def _expand_alias_refs(
             alias_to_expression[projection.alias] = (projection.this, i + 1)
 
     parent_scope = scope
-    while parent_scope.is_union:
+    on_right_sub_tree = False
+    while parent_scope and not parent_scope.is_cte:
+        if parent_scope.is_union:
+            on_right_sub_tree = parent_scope.parent.expression.right is parent_scope.expression
         parent_scope = parent_scope.parent
 
     # We shouldn't expand aliases if they match the recursive CTE's columns
-    if parent_scope.is_cte:
+    # and we are in the recursive part (right sub tree) of the CTE
+    if parent_scope and on_right_sub_tree:
         cte = parent_scope.expression.parent
         if cte.find_ancestor(exp.With).recursive:
             for recursive_cte_column in cte.args["alias"].columns or cte.this.selects:

sqlglot/parser.py

@@ -1427,8 +1427,6 @@ class Parser(metaclass=_Parser):
 
     DISTINCT_TOKENS = {TokenType.DISTINCT}
 
-    NULL_TOKENS = {TokenType.NULL}
-
     UNNEST_OFFSET_ALIAS_TOKENS = TABLE_ALIAS_TOKENS - SET_OPERATIONS
 
     SELECT_START_TOKENS = {TokenType.L_PAREN, TokenType.WITH, TokenType.SELECT}
@@ -6079,6 +6077,9 @@ class Parser(metaclass=_Parser):
             constraint_kind = exp.ComputedColumnConstraint(
                 this=self._parse_assignment(),
                 persisted=persisted or self._match_text_seq("PERSISTED"),
+                data_type=exp.Var(this="AUTO")
+                if self._match_text_seq("AUTO")
+                else self._parse_types(),
                 not_null=self._match_pair(TokenType.NOT, TokenType.NULL),
             )
             constraints.append(self.expression(exp.ColumnConstraint, kind=constraint_kind))
@@ -6974,16 +6975,27 @@ class Parser(metaclass=_Parser):
 
     def _parse_substring(self) -> exp.Substring:
         # Postgres supports the form: substring(string [from int] [for int])
+        # (despite being undocumented, the reverse order also works)
         # https://www.postgresql.org/docs/9.1/functions-string.html @ Table 9-6
 
         args = t.cast(t.List[t.Optional[exp.Expression]], self._parse_csv(self._parse_bitwise))
 
-        if self._match(TokenType.FROM):
-            args.append(self._parse_bitwise())
-        if self._match(TokenType.FOR):
-            if len(args) == 1:
-                args.append(exp.Literal.number(1))
-            args.append(self._parse_bitwise())
+        start, length = None, None
+
+        while self._curr:
+            if self._match(TokenType.FROM):
+                start = self._parse_bitwise()
+            elif self._match(TokenType.FOR):
+                if not start:
+                    start = exp.Literal.number(1)
+                length = self._parse_bitwise()
+            else:
+                break
+
+        if start:
+            args.append(start)
+        if length:
+            args.append(length)
 
         return self.validate_expression(exp.Substring.from_arg_list(args), args)
 
@@ -7274,7 +7286,7 @@ class Parser(metaclass=_Parser):
         return self._parse_primary() or self._parse_var(any_token=True)
 
     def _parse_null(self) -> t.Optional[exp.Expression]:
-        if self._match_set(self.NULL_TOKENS):
+        if self._match_set((TokenType.NULL, TokenType.UNKNOWN)):
             return self.PRIMARY_PARSERS[TokenType.NULL](self, self._prev)
         return self._parse_placeholder()
 
@@ -7308,7 +7320,7 @@ class Parser(metaclass=_Parser):
         if self._match(TokenType.L_PAREN, advance=False):
             return self._parse_wrapped_csv(self._parse_expression)
 
-        expression = self._parse_expression()
+        expression = self._parse_alias(self._parse_assignment(), explicit=True)
         return [expression] if expression else None
 
     def _parse_csv(

sqlglot/serde.py

@@ -5,105 +5,113 @@ import typing as t
 from sqlglot import expressions as exp
 
 
-def dump(expr: exp.Expression) -> t.Dict[str, t.Any]:
+INDEX = "i"
+ARG_KEY = "k"
+IS_ARRAY = "a"
+CLASS = "c"
+TYPE = "t"
+COMMENTS = "o"
+META = "m"
+VALUE = "v"
+DATA_TYPE = "DataType.Type"
+
+
+def dump(expression: exp.Expression) -> t.List[t.Dict[str, t.Any]]:
     """
-    Dump an Expression into a JSON serializable dict.
+    Dump an Expression into a JSON serializable List.
     """
-
-    root: t.Dict[str, t.Any] = {}
-    stack = [(expr, root)]
+    i = 0
+    payloads = []
+    stack: t.List[t.Tuple[t.Any, t.Optional[int], t.Optional[str], bool]] = [
+        (expression, None, None, False)
+    ]
 
     while stack:
-        node, payload = stack.pop()
-
-        klass = node.__class__.__qualname__
-
-        if node.__class__.__module__ != exp.__name__:
-            klass = f"{node.__module__}.{klass}"
-
-        payload["class"] = klass
-
-        if node.type:
-            payload["type"] = dump(node.type)
-        if node.comments:
-            payload["comments"] = node.comments
-        if node._meta is not None:
-            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
-
-                    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
+        node, index, arg_key, is_array = stack.pop()
 
-    return root
+        payload: t.Dict[str, t.Any] = {}
+
+        if index is not None:
+            payload[INDEX] = index
+        if arg_key is not None:
+            payload[ARG_KEY] = arg_key
+        if is_array:
+            payload[IS_ARRAY] = is_array
+
+        payloads.append(payload)
+
+        if hasattr(node, "parent"):
+            klass = node.__class__.__qualname__
+
+            if node.__class__.__module__ != exp.__name__:
+                klass = f"{node.__module__}.{klass}"
+
+            payload[CLASS] = klass
+
+            if node.type:
+                payload[TYPE] = dump(node.type)
+            if node.comments:
+                payload[COMMENTS] = node.comments
+            if node._meta is not None:
+                payload[META] = node._meta
+            if node.args:
+                for k, vs in reversed(node.args.items()):
+                    if type(vs) is list:
+                        for v in reversed(vs):
+                            stack.append((v, i, k, True))
+                    elif vs is not None:
+                        stack.append((vs, i, k, False))
+        elif type(node) is exp.DataType.Type:
+            payload[CLASS] = DATA_TYPE
+            payload[VALUE] = node.value
+        else:
+            payload[VALUE] = node
+
+        i += 1
+
+    return payloads
 
 
 @t.overload
-def load(expression: None) -> None: ...
+def load(payloads: None) -> None: ...
 
 
 @t.overload
-def load(expression: t.Dict[str, t.Any]) -> exp.Expression: ...
+def load(payloads: t.List[t.Dict[str, t.Any]]) -> exp.Expression: ...
 
 
-def load(expression):
+def load(payloads):
     """
-    Load a dict generated by dump into an Expression.
+    Load a list of dicts generated by dump into an Expression.
     """
-    if expression is None:
+
+    if not payloads:
         return None
 
-    root = _load(expression)
-    stack = [(root, expression.get("args"))]
+    payload, *tail = payloads
+    root = _load(payload)
+    nodes = [root]
+    for payload in tail:
+        node = _load(payload)
+        nodes.append(node)
+        parent = nodes[payload[INDEX]]
+        arg_key = payload[ARG_KEY]
+
+        if payload.get(IS_ARRAY):
+            parent.append(arg_key, node)
+        else:
+            parent.set(arg_key, node)
 
-    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
 
 
 def _load(payload: t.Dict[str, t.Any]) -> exp.Expression | exp.DataType.Type:
-    class_name = payload["class"]
+    class_name = payload.get(CLASS)
 
-    if class_name == "DataType.Type":
-        return exp.DataType.Type(payload["value"])
+    if not class_name:
+        return payload[VALUE]
+    if class_name == DATA_TYPE:
+        return exp.DataType.Type(payload[VALUE])
 
     if "." in class_name:
         module_path, class_name = class_name.rsplit(".", maxsplit=1)
@@ -112,7 +120,7 @@ def _load(payload: t.Dict[str, t.Any]) -> exp.Expression | exp.DataType.Type:
         module = exp
 
     expression = getattr(module, class_name)()
-    expression.type = load(payload.get("type"))
-    expression.comments = payload.get("comments")
-    expression._meta = payload.get("meta")
+    expression.type = load(payload.get(TYPE))
+    expression.comments = payload.get(COMMENTS)
+    expression._meta = payload.get(META)
     return expression

sqlglot/tokens.py

@@ -398,6 +398,7 @@ class TokenType(AutoName):
     SIMILAR_TO = auto()
     SOME = auto()
     SORT_BY = auto()
+    SOUNDS_LIKE = auto()
     START_WITH = auto()
     STORAGE_INTEGRATION = auto()
     STRAIGHT_JOIN = auto()

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

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

{sqlglot-27.14.0.dist-info → sqlglot-27.15.1.dist-info}/RECORD

@@ -1,26 +1,26 @@
 sqlglot/__init__.py,sha256=za08rtdPh2v7dOpGdNomttlIVGgTrKja7rPd6sQwaTg,5391
 sqlglot/__main__.py,sha256=022c173KqxsiABWTEpUIq_tJUxuNiW7a7ABsxBXqvu8,2069
 sqlglot/_typing.py,sha256=-1HPyr3w5COlSJWqlgt8jhFk2dyMvBuvVBqIX1wyVCM,642
-sqlglot/_version.py,sha256=dO3zbTXGDFSvRTydZPKWrc0n8_OL2jG2s0_3yJeMyuY,708
+sqlglot/_version.py,sha256=uBjOfOPRa2Q_ZQoGTa7Z6DXUQYBsQngq3pkSoTX6oxQ,708
 sqlglot/diff.py,sha256=PtOllQMQa1Sw1-V2Y8eypmDqGujXYPaTOp_WLsWkAWk,17314
 sqlglot/errors.py,sha256=QNKMr-pzLUDR-tuMmn_GK6iMHUIVdb_YSJ_BhGEvuso,2126
-sqlglot/expressions.py,sha256=LteUkI-eNj_xG4AvHTGuzqcZb2elWXygT5dR1FcxudI,254734
-sqlglot/generator.py,sha256=5A8fDNIE6u_SuTiSLR4tLDfmoA5LRG9nHIEMqVutaMg,225102
+sqlglot/expressions.py,sha256=P9Da86Bo1Ufv1oZFs3ESJ1WDlc6tjvr-qz5BAd8_ek8,255449
+sqlglot/generator.py,sha256=m4UHZpDrh52RZzv_iBqMnhv_j4DmhtpY1CtVyiGIJ8k,225187
 sqlglot/helper.py,sha256=9nZjFVRBtMKFC3EdzpDQ6jkazFO19po6BF8xHiNGZIo,15111
 sqlglot/jsonpath.py,sha256=SQgaxzaEYBN7At9dkTK4N1Spk6xHxvHL6QtCIP6iM30,7905
 sqlglot/lineage.py,sha256=Qj5ykuDNcATppb9vOjoIKBqRVLbu3OMPiZk9f3iyv40,15312
-sqlglot/parser.py,sha256=YECjuYjATlMIqgHyEyRDjG7Xm0Of2fHfsm2UgLCYNP0,334925
+sqlglot/parser.py,sha256=7qwpwjE1P40aaXE83uS1sEyty901Iu6y2m4sgJPZ2Ew,335358
 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=MFPE_7FgJx_kAZZFoaobj38jCjT6jfGghJUjzZBEUMs,3426
+sqlglot/serde.py,sha256=nWpBFUjwZh06Li4qBuNb0YRU_QyflzSVyWkFxujM0WM,3175
 sqlglot/time.py,sha256=Q62gv6kL40OiRBF6BMESxKJcMVn7ZLNw7sv8H34z5FI,18400
-sqlglot/tokens.py,sha256=_Esqa2AB1PI7o7EUkupGUQYCvriE71O8J7BQiYySHC0,49146
+sqlglot/tokens.py,sha256=fHH_44_p4-AH9o0scLPkF6bqKT-Tyc-Fk_ba-Gvp5-E,49171
 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=Oz9_pYUhVHBjHschYvar4V9hgz8KywokEV0y4hNXi7w,72371
+sqlglot/dialects/bigquery.py,sha256=9Q-oCXcpa2vrT2eMgVGHWwEvECMm4RQeV1XkjJj0nPA,72483
 sqlglot/dialects/clickhouse.py,sha256=OzcDAS7pWs889gu0aLYn_HIjTLiPRjGFG61p6-84stE,58574
 sqlglot/dialects/databricks.py,sha256=H4QTq7gg6tJylKc_YWsGp6049KydoI_wlQUHM7iCJtI,4753
 sqlglot/dialects/dialect.py,sha256=BU4-x1d8tRCSAfdpeP5b86me0wXfgpcEPdyk27wLgg4,73293
@@ -34,15 +34,15 @@ sqlglot/dialects/exasol.py,sha256=ay3g_VyT5WvHTgNyJuCQu0nBt4bpllLZ9IdMBizEgYM,15
 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=YuLyZBrEw4qSacd_1LGLJX4n-P99alnhQmANBlSFT4o,49408
+sqlglot/dialects/mysql.py,sha256=0s7RIpWPCaBYvxgR8Z6JWPub1BHBB_0Th7KHCIXVfms,49702
 sqlglot/dialects/oracle.py,sha256=zWPCpzGiTlgCJ5E6FjfX3Rszjcw4SnHg6xeVboMYIyo,15972
-sqlglot/dialects/postgres.py,sha256=Zr5b0Yl5yXDKANcvUtnRsWUXLkbeEBZjwzFDAGtuub0,34296
+sqlglot/dialects/postgres.py,sha256=KcvDIfl99EqOZ7nQ1Ey1IqcQMkAuXiN4SJqyvo95c2g,34674
 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=FIwtP3yEg-way9pa32kxCJc6IaFkHVIvgYKZA-Ilmi0,15919
 sqlglot/dialects/risingwave.py,sha256=BqWwW1iT_OIVMwfRamaww79snnBwIgCfr22Go-ggO68,3289
-sqlglot/dialects/singlestore.py,sha256=GJrMoUK366JsQZyS_L8oGVkMkiVty1tijy7zqWAJ6Ck,61290
-sqlglot/dialects/snowflake.py,sha256=mmBa0iHgBDSo9M508cdluWzEjvMbTotLRERS3-ybsVI,73091
+sqlglot/dialects/singlestore.py,sha256=0QqNYOucNklPQuyeGcsisLI97qPGx_RfWKOFarJz2qw,61711
+sqlglot/dialects/snowflake.py,sha256=tgUJ77_Ntm1QcCbwlvI-j0_R96s0l6zFUUqysHIEez8,75351
 sqlglot/dialects/spark.py,sha256=PzyhkelDzbCMgJ3RVHD6yyzLIFp9NdZfwVas5IymowM,10147
 sqlglot/dialects/spark2.py,sha256=qz36FT9k4iuiqboRpyG4VpKGkPR0P2fifmqgZ9gNUEU,14851
 sqlglot/dialects/sqlite.py,sha256=zzXEbnaLjJeg6hPLHricjpfSkuf8tpXECnjcHtoqIbw,13263
@@ -50,14 +50,14 @@ sqlglot/dialects/starrocks.py,sha256=2gav0PSNgRdAGXzawdznZliBpglJoQ0wBxPI7ZIMsRw
 sqlglot/dialects/tableau.py,sha256=oIawDzUITxGCWaEMB8OaNMPWhbC3U-2y09pYPm4eazc,2190
 sqlglot/dialects/teradata.py,sha256=7LxCcRwP0Idd_OnCzA57NCdheVjHcKC2aFAKG5N49IU,18202
 sqlglot/dialects/trino.py,sha256=Z7prRhCxIBh0KCxIQpWmVOIGHCJM9Xl5oRlqySxln4Y,4350
-sqlglot/dialects/tsql.py,sha256=kfzHDyKdciqwre6mjZaRHP9tnqfPSPjcM9SP9C045VA,54075
+sqlglot/dialects/tsql.py,sha256=7pVL3H-qNLCnoHqBEVSIVKhlTqoPmiYBRtg_HVv8zH4,54462
 sqlglot/executor/__init__.py,sha256=FslewzYQtQdDNg_0Ju2UaiP4vo4IMUgkfkmFsYUhcN0,2958
 sqlglot/executor/context.py,sha256=WJHJdYQCOeVXwLw0uSSrWSc25eBMn5Ix108RCvdsKRQ,3386
 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=RuBjs-mnWjH-wa02UKPMPq-3ymjQ_X7_t7Vz9xNhNOA,26202
+sqlglot/optimizer/annotate_types.py,sha256=E3oqbGWD7Lb8DhGakLG8R_be8MIaBWTBXLk0RxCQFro,26400
 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
@@ -71,13 +71,13 @@ sqlglot/optimizer/optimizer.py,sha256=vXEXDWHvbO-vJmSI7UqJuydM2WrD1xko7rETq2EtVJ
 sqlglot/optimizer/pushdown_predicates.py,sha256=HGjs3Z4V3-X2d1VTfWhyByY3aL5SmKnVvt3aDXiiBM0,8414
 sqlglot/optimizer/pushdown_projections.py,sha256=7NoK5NAUVYVhs0YnYyo6WuXfaO-BShSwS6lA8Y-ATQ4,6668
 sqlglot/optimizer/qualify.py,sha256=oAPfwub7dEkrlCrsptcJWpLya4BgKhN6M5SwIs_86LY,4002
-sqlglot/optimizer/qualify_columns.py,sha256=LUlHSSyKshgWIhn4es2PzR1iAvMoSkwHY2t8h07Y32I,45037
+sqlglot/optimizer/qualify_columns.py,sha256=7aabZhD-dKNiwIW_ZjOEr0RPbWfhSbuR-WI6NnVCZAA,45298
 sqlglot/optimizer/qualify_tables.py,sha256=dA4ZazL7ShQh2JgBwpHuG-4c5lBw1TNzCnuN7m0iVTA,6645
 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.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,,
+sqlglot-27.15.1.dist-info/licenses/LICENSE,sha256=p1Yk0B4oa0l8Rh-_dYyy75d8spjPd_vTloXfz4FWxys,1065
+sqlglot-27.15.1.dist-info/METADATA,sha256=8AtINMRFBT71fI3AeuKwjYmOPm3PRDtPEnjqBauQHas,20682
+sqlglot-27.15.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sqlglot-27.15.1.dist-info/top_level.txt,sha256=5kRskCGA_gVADF9rSfSzPdLHXqvfMusDYeHePfNY2nQ,8
+sqlglot-27.15.1.dist-info/RECORD,,