sqlglot 27.13.2__py3-none-any.whl → 27.15.0__py3-none-any.whl

sqlglot/parser.py

@@ -942,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 = {
@@ -1424,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}
@@ -1555,6 +1556,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",
@@ -3205,9 +3210,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_))
@@ -3235,6 +3241,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,
@@ -3243,13 +3250,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
 
@@ -3876,6 +3882,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]:
@@ -4407,6 +4423,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)
@@ -5396,7 +5414,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)
@@ -5532,6 +5550,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
 
@@ -5805,6 +5828,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,
@@ -5869,7 +5895,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:
@@ -6051,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))
@@ -7246,7 +7275,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()
 
@@ -7280,7 +7309,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(
@@ -8370,6 +8399,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,123 @@ 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]
 
+INDEX = "i"
+ARG_KEY = "k"
+IS_ARRAY = "a"
+CLASS = "c"
+TYPE = "t"
+COMMENTS = "o"
+META = "m"
+VALUE = "v"
+DATA_TYPE = "DataType.Type"
 
-def dump(node: Node) -> JSON:
+
+def dump(expression: exp.Expression) -> t.List[t.Dict[str, t.Any]]:
     """
-    Recursively dump an AST into a JSON-serializable dict.
+    Dump an Expression into a JSON serializable List.
     """
-    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):
-        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 != []},
-        }
-        if node.type:
-            obj["type"] = dump(node.type)
-        if node.comments:
-            obj["comments"] = node.comments
-        if node._meta is not None:
-            obj["meta"] = node._meta
-
-        return obj
-    return node
-
-
-def load(obj: JSON) -> Node:
+    i = 0
+    payloads = []
+    stack: t.List[t.Tuple[t.Any, t.Optional[int], t.Optional[str], bool]] = [
+        (expression, None, None, False)
+    ]
+
+    while stack:
+        node, index, arg_key, is_array = stack.pop()
+
+        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(payloads: None) -> None: ...
+
+
+@t.overload
+def load(payloads: t.List[t.Dict[str, t.Any]]) -> exp.Expression: ...
+
+
+def load(payloads):
     """
-    Recursively load a dict (as returned by `dump`) into an AST.
+    Load a list of dicts 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 class_name == "DataType.Type":
-            return exp.DataType.Type(obj["value"])
+    if not payloads:
+        return None
+
+    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 "." in class_name:
-            module_path, class_name = class_name.rsplit(".", maxsplit=1)
-            module = __import__(module_path, fromlist=[class_name])
+        if payload.get(IS_ARRAY):
+            parent.append(arg_key, node)
         else:
-            module = exp
+            parent.set(arg_key, node)
+
+    return root
+
+
+def _load(payload: t.Dict[str, t.Any]) -> exp.Expression | exp.DataType.Type:
+    class_name = payload.get(CLASS)
 
-        klass = getattr(module, class_name)
+    if not class_name:
+        return payload[VALUE]
+    if class_name == DATA_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()
 
@@ -395,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.13.2.dist-info → sqlglot-27.15.0.dist-info}/METADATA

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

{sqlglot-27.13.2.dist-info → sqlglot-27.15.0.dist-info}/RECORD

@@ -1,63 +1,63 @@
 sqlglot/__init__.py,sha256=za08rtdPh2v7dOpGdNomttlIVGgTrKja7rPd6sQwaTg,5391
 sqlglot/__main__.py,sha256=022c173KqxsiABWTEpUIq_tJUxuNiW7a7ABsxBXqvu8,2069
 sqlglot/_typing.py,sha256=-1HPyr3w5COlSJWqlgt8jhFk2dyMvBuvVBqIX1wyVCM,642
-sqlglot/_version.py,sha256=Qfj_wDzloXYOzTK9Ff0q4plSvKrkjROgU8iPJJemDqA,708
+sqlglot/_version.py,sha256=KVLKBMiChkTVkTm8LDtrlmQe6kAjOFYgfWf9NfPngWM,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=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=wouCp_0fjj7xFqK6R3lt1LFVpk0f3qCsWQcvQnIWSQM,333289
+sqlglot/parser.py,sha256=woN7sh4ol7HcMNXzDIQbeuMnvHQ337MiNQPk-5lxZPY,335079
 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=nWpBFUjwZh06Li4qBuNb0YRU_QyflzSVyWkFxujM0WM,3175
 sqlglot/time.py,sha256=Q62gv6kL40OiRBF6BMESxKJcMVn7ZLNw7sv8H34z5FI,18400
-sqlglot/tokens.py,sha256=GuRPOipxixWdEJDxIat9ZLPAn3JhQ2cP94qvOelXogU,49076
+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=IO5u1sdT0wzl76_z3FVm8FgtVnnMBrFPab-HhxuxROs,72078
-sqlglot/dialects/clickhouse.py,sha256=YLY8s7oCfdCoD0X2iOIltivXXjtT_nJdb3931P0TDeU,58553
+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=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=0s7RIpWPCaBYvxgR8Z6JWPub1BHBB_0Th7KHCIXVfms,49702
 sqlglot/dialects/oracle.py,sha256=zWPCpzGiTlgCJ5E6FjfX3Rszjcw4SnHg6xeVboMYIyo,15972
-sqlglot/dialects/postgres.py,sha256=NsaNBKUrqzb3bjVi16IBlYi8FPJnHRTl46lQX1GDNzw,33849
+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=_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=A3k54EodIUxwTnnBazefDHO5mxon0zSg43mep-VG_7E,72042
+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=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
 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=MfxXNzYgxaqhv1yBmzuigWjc1oIw1ikZ_lXjcdT3RDc,25128
+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.13.2.dist-info/licenses/LICENSE,sha256=p1Yk0B4oa0l8Rh-_dYyy75d8spjPd_vTloXfz4FWxys,1065
-sqlglot-27.13.2.dist-info/METADATA,sha256=OL06yiI1dWjxy0Z_rIYYoKTcEzkYr1aCkOn-fvZ48Y4,20682
-sqlglot-27.13.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sqlglot-27.13.2.dist-info/top_level.txt,sha256=5kRskCGA_gVADF9rSfSzPdLHXqvfMusDYeHePfNY2nQ,8
-sqlglot-27.13.2.dist-info/RECORD,,
+sqlglot-27.15.0.dist-info/licenses/LICENSE,sha256=p1Yk0B4oa0l8Rh-_dYyy75d8spjPd_vTloXfz4FWxys,1065
+sqlglot-27.15.0.dist-info/METADATA,sha256=8y7rLoqBMae_bNKyR6wVJnGJNlO-UTAVbDbvaHBzZgc,20682
+sqlglot-27.15.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sqlglot-27.15.0.dist-info/top_level.txt,sha256=5kRskCGA_gVADF9rSfSzPdLHXqvfMusDYeHePfNY2nQ,8
+sqlglot-27.15.0.dist-info/RECORD,,