sqlglot 27.4.1__py3-none-any.whl → 27.5.1__py3-none-any.whl

sqlglot/dialects/snowflake.py

@@ -655,12 +655,6 @@ class Snowflake(Dialect):
 
         TIMESTAMPS = parser.Parser.TIMESTAMPS - {TokenType.TIME}
 
-        RANGE_PARSERS = {
-            **parser.Parser.RANGE_PARSERS,
-            TokenType.LIKE_ANY: parser.binary_range_parser(exp.LikeAny),
-            TokenType.ILIKE_ANY: parser.binary_range_parser(exp.ILikeAny),
-        }
-
         ALTER_PARSERS = {
             **parser.Parser.ALTER_PARSERS,
             "UNSET": lambda self: self.expression(
@@ -1133,8 +1127,6 @@ class Snowflake(Dialect):
             "EXCLUDE": TokenType.EXCEPT,
             "FILE FORMAT": TokenType.FILE_FORMAT,
             "GET": TokenType.GET,
-            "ILIKE ANY": TokenType.ILIKE_ANY,
-            "LIKE ANY": TokenType.LIKE_ANY,
             "MATCH_CONDITION": TokenType.MATCH_CONDITION,
             "MATCH_RECOGNIZE": TokenType.MATCH_RECOGNIZE,
             "MINUS": TokenType.EXCEPT,

sqlglot/expressions.py

@@ -940,15 +940,18 @@ class Expression(metaclass=_Expression):
         low: t.Any,
         high: t.Any,
         copy: bool = True,
-        symmetric: t.Optional[bool] = False,
+        symmetric: t.Optional[bool] = None,
         **opts,
     ) -> Between:
-        return Between(
+        between = Between(
             this=maybe_copy(self, copy),
             low=convert(low, copy=copy, **opts),
             high=convert(high, copy=copy, **opts),
-            symmetric=symmetric,
         )
+        if symmetric is not None:
+            between.set("symmetric", symmetric)
+
+        return between
 
     def is_(self, other: ExpOrStr) -> Is:
         return self._binop(Is, other)
@@ -4546,6 +4549,7 @@ class DataType(Expression):
         FIXEDSTRING = auto()
         FLOAT = auto()
         GEOGRAPHY = auto()
+        GEOGRAPHYPOINT = auto()
         GEOMETRY = auto()
         POINT = auto()
         RING = auto()
@@ -5093,10 +5097,6 @@ class ILike(Binary, Predicate):
     pass
 
 
-class ILikeAny(Binary, Predicate):
-    pass
-
-
 class IntDiv(Binary):
     pass
 
@@ -5113,10 +5113,6 @@ class Like(Binary, Predicate):
     pass
 
 
-class LikeAny(Binary, Predicate):
-    pass
-
-
 class LT(Binary, Predicate):
     pass
 

sqlglot/generator.py

@@ -491,6 +491,9 @@ class Generator(metaclass=_Generator):
     # Whether SYMMETRIC and ASYMMETRIC flags are supported with BETWEEN expression
     SUPPORTS_BETWEEN_FLAGS = False
 
+    # Whether LIKE and ILIKE support quantifiers such as LIKE ANY/ALL/SOME
+    SUPPORTS_LIKE_QUANTIFIERS = True
+
     TYPE_MAPPING = {
         exp.DataType.Type.DATETIME2: "TIMESTAMP",
         exp.DataType.Type.NCHAR: "CHAR",
@@ -2898,7 +2901,10 @@ class Generator(metaclass=_Generator):
         return f"{self.sql(expression, 'this')}[{expressions_sql}]"
 
     def all_sql(self, expression: exp.All) -> str:
-        return f"ALL {self.wrap(expression)}"
+        this = self.sql(expression, "this")
+        if not isinstance(expression.this, (exp.Tuple, exp.Paren)):
+            this = self.wrap(this)
+        return f"ALL {this}"
 
     def any_sql(self, expression: exp.Any) -> str:
         this = self.sql(expression, "this")
@@ -3648,12 +3654,6 @@ class Generator(metaclass=_Generator):
     def gte_sql(self, expression: exp.GTE) -> str:
         return self.binary(expression, ">=")
 
-    def ilike_sql(self, expression: exp.ILike) -> str:
-        return self.binary(expression, "ILIKE")
-
-    def ilikeany_sql(self, expression: exp.ILikeAny) -> str:
-        return self.binary(expression, "ILIKE ANY")
-
     def is_sql(self, expression: exp.Is) -> str:
         if not self.IS_BOOL_ALLOWED and isinstance(expression.expression, exp.Boolean):
             return self.sql(
@@ -3661,11 +3661,38 @@ class Generator(metaclass=_Generator):
             )
         return self.binary(expression, "IS")
 
+    def _like_sql(self, expression: exp.Like | exp.ILike) -> str:
+        this = expression.this
+        rhs = expression.expression
+
+        if isinstance(expression, exp.Like):
+            exp_class: t.Type[exp.Like | exp.ILike] = exp.Like
+            op = "LIKE"
+        else:
+            exp_class = exp.ILike
+            op = "ILIKE"
+
+        if isinstance(rhs, (exp.All, exp.Any)) and not self.SUPPORTS_LIKE_QUANTIFIERS:
+            exprs = rhs.this.unnest()
+
+            if isinstance(exprs, exp.Tuple):
+                exprs = exprs.expressions
+
+            connective = exp.or_ if isinstance(rhs, exp.Any) else exp.and_
+
+            like_expr: exp.Expression = exp_class(this=this, expression=exprs[0])
+            for expr in exprs[1:]:
+                like_expr = connective(like_expr, exp_class(this=this, expression=expr))
+
+            return self.sql(like_expr)
+
+        return self.binary(expression, op)
+
     def like_sql(self, expression: exp.Like) -> str:
-        return self.binary(expression, "LIKE")
+        return self._like_sql(expression)
 
-    def likeany_sql(self, expression: exp.LikeAny) -> str:
-        return self.binary(expression, "LIKE ANY")
+    def ilike_sql(self, expression: exp.ILike) -> str:
+        return self._like_sql(expression)
 
     def similarto_sql(self, expression: exp.SimilarTo) -> str:
         return self.binary(expression, "SIMILAR TO")

sqlglot/optimizer/eliminate_joins.py

@@ -32,6 +32,9 @@ def eliminate_joins(expression):
 
         # Reverse the joins so we can remove chains of unused joins
         for join in reversed(joins):
+            if join.is_semi_or_anti_join:
+                continue
+
             alias = join.alias_or_name
             if _should_eliminate_join(scope, join, alias):
                 join.pop()

sqlglot/optimizer/scope.py

@@ -523,6 +523,12 @@ class Scope:
             for _, source in scope.selected_sources.values():
                 scope_ref_count[id(source)] += 1
 
+            for name in scope._semi_anti_join_tables:
+                # semi/anti join sources are not actually selected but we still need to
+                # increment their ref count to avoid them being optimized away
+                if name in scope.sources:
+                    scope_ref_count[id(scope.sources[name])] += 1
+
         return scope_ref_count
 
 

sqlglot/parser.py

@@ -380,6 +380,7 @@ class Parser(metaclass=_Parser):
         TokenType.BIGDECIMAL,
         TokenType.UUID,
         TokenType.GEOGRAPHY,
+        TokenType.GEOGRAPHYPOINT,
         TokenType.GEOMETRY,
         TokenType.POINT,
         TokenType.RING,
@@ -1136,7 +1137,14 @@ class Parser(metaclass=_Parser):
         "TRUNCATE": lambda self: self._parse_partitioned_by_bucket_or_truncate(),
     }
 
-    def _parse_partitioned_by_bucket_or_truncate(self) -> exp.Expression:
+    def _parse_partitioned_by_bucket_or_truncate(self) -> t.Optional[exp.Expression]:
+        if not self._match(TokenType.L_PAREN, advance=False):
+            # Partitioning by bucket or truncate follows the syntax:
+            # PARTITION BY (BUCKET(..) | TRUNCATE(..))
+            # If we don't have parenthesis after each keyword, we should instead parse this as an identifier
+            self._retreat(self._index - 1)
+            return None
+
         klass = (
             exp.PartitionedByBucket
             if self._prev.text.upper() == "BUCKET"
@@ -5767,6 +5775,7 @@ class Parser(metaclass=_Parser):
             return None
 
         comments = self._curr.comments
+        prev = self._prev
         token = self._curr
         token_type = self._curr.token_type
         this = self._curr.text
@@ -5798,12 +5807,19 @@ class Parser(metaclass=_Parser):
         else:
             subquery_predicate = self.SUBQUERY_PREDICATES.get(token_type)
 
-            if subquery_predicate and self._curr.token_type in (TokenType.SELECT, TokenType.WITH):
-                this = self.expression(
-                    subquery_predicate, comments=comments, this=self._parse_select()
-                )
-                self._match_r_paren()
-                return this
+            if subquery_predicate:
+                expr = None
+                if self._curr.token_type in (TokenType.SELECT, TokenType.WITH):
+                    expr = self._parse_select()
+                    self._match_r_paren()
+                elif prev and prev.token_type in (TokenType.LIKE, TokenType.ILIKE):
+                    # Backtrack one token since we've consumed the L_PAREN here. Instead, we'd like
+                    # to parse "LIKE [ANY | ALL] (...)" as a whole into an exp.Tuple or exp.Paren
+                    self._advance(-1)
+                    expr = self._parse_bitwise()
+
+                if expr:
+                    return self.expression(subquery_predicate, comments=comments, this=expr)
 
             if functions is None:
                 functions = self.FUNCTIONS
@@ -6194,7 +6210,7 @@ class Parser(metaclass=_Parser):
         return self._parse_id_var(any_token=False)
 
     def _parse_unique(self) -> exp.UniqueColumnConstraint:
-        self._match_text_seq("KEY")
+        self._match_texts(("KEY", "INDEX"))
         return self.expression(
             exp.UniqueColumnConstraint,
             nulls=self._match_text_seq("NULLS", "NOT", "DISTINCT"),

sqlglot/tokens.py

@@ -39,6 +39,8 @@ class TokenType(AutoName):
     COLON = auto()
     DOTCOLON = auto()
     DCOLON = auto()
+    DCOLONDOLLAR = auto()
+    DCOLONPERCENT = auto()
     DQMARK = auto()
     SEMICOLON = auto()
     STAR = auto()
@@ -53,6 +55,8 @@ class TokenType(AutoName):
     NEQ = auto()
     NULLSAFE_EQ = auto()
     COLON_EQ = auto()
+    COLON_GT = auto()
+    NCOLON_GT = auto()
     AND = auto()
     OR = auto()
     AMP = auto()
@@ -183,6 +187,7 @@ class TokenType(AutoName):
     DATEMULTIRANGE = auto()
     UUID = auto()
     GEOGRAPHY = auto()
+    GEOGRAPHYPOINT = auto()
     NULLABLE = auto()
     GEOMETRY = auto()
     POINT = auto()
@@ -301,7 +306,6 @@ class TokenType(AutoName):
     HINT = auto()
     IGNORE = auto()
     ILIKE = auto()
-    ILIKE_ANY = auto()
     IN = auto()
     INDEX = auto()
     INNER = auto()
@@ -322,7 +326,6 @@ class TokenType(AutoName):
     LATERAL = auto()
     LEFT = auto()
     LIKE = auto()
-    LIKE_ANY = auto()
     LIMIT = auto()
     LIST = auto()
     LOAD = auto()

sqlglot/transforms.py

@@ -990,7 +990,7 @@ def any_to_exists(expression: exp.Expression) -> exp.Expression:
     if isinstance(expression, exp.Select):
         for any_expr in expression.find_all(exp.Any):
             this = any_expr.this
-            if isinstance(this, exp.Query):
+            if isinstance(this, exp.Query) or isinstance(any_expr.parent, (exp.Like, exp.ILike)):
                 continue
 
             binop = any_expr.parent

{sqlglot-27.4.1.dist-info → sqlglot-27.5.1.dist-info}/METADATA

@@ -1,30 +1,8 @@
 Metadata-Version: 2.4
 Name: sqlglot
-Version: 27.4.1
+Version: 27.5.1
 Summary: An easily customizable SQL parser and transpiler
 Author-email: Toby Mao <toby.mao@gmail.com>
-License: MIT License
-        
-        Copyright (c) 2023 Toby Mao
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
 Project-URL: Homepage, https://sqlglot.com/
 Project-URL: Documentation, https://sqlglot.com/sqlglot.html
 Project-URL: Repository, https://github.com/tobymao/sqlglot
@@ -32,7 +10,6 @@ Project-URL: Issues, https://github.com/tobymao/sqlglot/issues
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: SQL
 Classifier: Programming Language :: Python :: 3 :: Only

{sqlglot-27.4.1.dist-info → sqlglot-27.5.1.dist-info}/RECORD

@@ -1,22 +1,22 @@
 sqlglot/__init__.py,sha256=za08rtdPh2v7dOpGdNomttlIVGgTrKja7rPd6sQwaTg,5391
 sqlglot/__main__.py,sha256=022c173KqxsiABWTEpUIq_tJUxuNiW7a7ABsxBXqvu8,2069
 sqlglot/_typing.py,sha256=-1HPyr3w5COlSJWqlgt8jhFk2dyMvBuvVBqIX1wyVCM,642
-sqlglot/_version.py,sha256=jOZXO_b65dIa3g-RaYPPvo31yJxPamFz_P4zbdxLZ2o,513
+sqlglot/_version.py,sha256=lEPcd62DijGiIa_sz50zyHEi74AH-53vHCq2mbltrig,513
 sqlglot/diff.py,sha256=PtOllQMQa1Sw1-V2Y8eypmDqGujXYPaTOp_WLsWkAWk,17314
 sqlglot/errors.py,sha256=QNKMr-pzLUDR-tuMmn_GK6iMHUIVdb_YSJ_BhGEvuso,2126
-sqlglot/expressions.py,sha256=Q52dXK5i-R4jtqHd2-Tj533GiOHxATrPxot68oV7Vfc,246122
-sqlglot/generator.py,sha256=6SXy3-2Lnn1UGPTe6aMKzeNJxU7mZwJaQcrBLHCVL_c,216858
+sqlglot/expressions.py,sha256=L8eo53HkSOsPisQIE-mAhiO3o52cgMXEG8XPAlft3Ck,246138
+sqlglot/generator.py,sha256=HgUGW8vGaSTRIbGz9aCpK7uOcGlt7UdPWhcYqHZSB0w,217786
 sqlglot/helper.py,sha256=9nZjFVRBtMKFC3EdzpDQ6jkazFO19po6BF8xHiNGZIo,15111
 sqlglot/jsonpath.py,sha256=jneO-A57n4ojVT2drCn2HBlx_Ka8wLcGpemW1JgvbjA,7666
 sqlglot/lineage.py,sha256=Qj5ykuDNcATppb9vOjoIKBqRVLbu3OMPiZk9f3iyv40,15312
-sqlglot/parser.py,sha256=LpUn9mCDkYfJPjzNRx9vHKl0tfYzhWSbCn_76yybbvY,326921
+sqlglot/parser.py,sha256=IGRj3zKCRpKolV8srQvBOsQCF_iH27N2Lb3qpefJPg0,327777
 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/time.py,sha256=Q62gv6kL40OiRBF6BMESxKJcMVn7ZLNw7sv8H34z5FI,18400
-sqlglot/tokens.py,sha256=q9L6YtVIMLUDcl652eWFXMsa5lsrGECcHQpDy_9BDF0,48856
-sqlglot/transforms.py,sha256=s96QMtR7rJbcLAU1I_IF1xLNxno6yvEbhERgbS5xmJ4,41164
+sqlglot/tokens.py,sha256=ibw_XDjfMgX80ScCwXXrxKLyKCSmHWwZhxPkmKF7q3I,48937
+sqlglot/transforms.py,sha256=utNDsCBsA7hPUK3-aby3DDgiY_XVMAKQqeoLm1EyihI,41218
 sqlglot/trie.py,sha256=v27uXMrHfqrXlJ6GmeTSMovsB_3o0ctnlKhdNt7W6fI,2245
 sqlglot/dialects/__init__.py,sha256=BQUv9EuMmvhP_wVitGLo0PlCi15atvfXgvREpsTsxeQ,3799
 sqlglot/dialects/athena.py,sha256=ofArmayYLev4qZQ15GM8mevG04qqR5WGFb2ZcuYm6x4,10966
@@ -28,21 +28,21 @@ sqlglot/dialects/doris.py,sha256=g6KGYu01nUsvz_wjZkZbI0tiPg-ZUKyr7a-yGaw5Kec,198
 sqlglot/dialects/dremio.py,sha256=FbBTri3KPD4oJMKV9Qdnh7_EgLJUZZB8iDzUlDE26h4,4077
 sqlglot/dialects/drill.py,sha256=FOh7_KjPx_77pv0DiHKZog0CcmzqeF9_PEmGnJ1ESSM,5825
 sqlglot/dialects/druid.py,sha256=kh3snZtneehNOWqs3XcPjsrhNaRbkCQ8E4hHbWJ1fHM,690
-sqlglot/dialects/duckdb.py,sha256=MUGm1cqpWHBrQBefwPXq2F96G-Tthshcp97hGhVt4Bs,51376
+sqlglot/dialects/duckdb.py,sha256=X4nY2ZjUSGZZ3pCqUraGxIYXVA-gzB134qV0TeyMmqQ,51418
 sqlglot/dialects/dune.py,sha256=gALut-fFfN2qMsr8LvZ1NQK3F3W9z2f4PwMvTMXVVVg,375
-sqlglot/dialects/exasol.py,sha256=imRzqWpgcQK0E5WrBTSy3JvTYs9zgkD3TC5Qbe4Hb7Y,10127
+sqlglot/dialects/exasol.py,sha256=EMA9hBttHHnt0lIj0BN5_se8x-ve7TrKrhIfmbVkaaQ,11968
 sqlglot/dialects/fabric.py,sha256=4Sng2ZhQSaf6eK3ituR9DqDZERaVwYS_UfdpusjsISg,10220
 sqlglot/dialects/hive.py,sha256=bAZz0qnaOH9f5FyIMkqBu3XB2Cj7y-xnCPbxPsk8U9I,31959
-sqlglot/dialects/materialize.py,sha256=_DPLPt8YrdQIIXNrGJw1IMcGOoAEJ9NO9X9pDfy4hxs,3494
+sqlglot/dialects/materialize.py,sha256=LD2q1kTRrCwkIu1BfoBvnjTGbupDtoQ8JQMDCIYAXHg,3533
 sqlglot/dialects/mysql.py,sha256=J_88qeXxC_oD09yMiNgw_so3x2QlaqL5l7CRku1R6wo,49280
-sqlglot/dialects/oracle.py,sha256=lzjL13ALnAEAQYSvqhLJINnDCaTLllYP3CUqVPtdZ2o,16003
-sqlglot/dialects/postgres.py,sha256=Kkebjjhiw3HsyJJSQ63-S4uo3QmOR53nVuLpNBGNJi8,33982
+sqlglot/dialects/oracle.py,sha256=DpckKjR3FauVmXDIDaNTFqJE0KzXnW4sUlnZjQC8z0Y,15735
+sqlglot/dialects/postgres.py,sha256=8QF9uEXXFAGCXQah1n8mv4fonF58o0n59Il66hOZYqI,33942
 sqlglot/dialects/presto.py,sha256=Tm3Bx9AJilT1xlgunTpF0wUhIZBOPS-rB5Iwitnygxc,33462
 sqlglot/dialects/prql.py,sha256=fwN-SPEGx-drwf1K0U2MByN-PkW3C_rOgQ3xeJeychg,7908
-sqlglot/dialects/redshift.py,sha256=PAet4ka9JWyZImRl_b4qucgDGMrMlUt_pqry3XxZc1w,15783
-sqlglot/dialects/risingwave.py,sha256=fEB3ySAcF2N1UjwD_JjcOkRu3F6DQ852XBrwava-CjY,3250
-sqlglot/dialects/singlestore.py,sha256=S_NRGnHrzyDh5J8_NUs5fKACB7BL7t5SnkZ_0l0Cf0E,102
-sqlglot/dialects/snowflake.py,sha256=PuAvhs6dhDg3Dwnygi6OBy9cxp7My2ZUH0j27eWnM8E,70805
+sqlglot/dialects/redshift.py,sha256=MXI9W7CgKCtMNjNRPcZPxO8NBA9_PxZx14HB52o-aUc,15822
+sqlglot/dialects/risingwave.py,sha256=BqWwW1iT_OIVMwfRamaww79snnBwIgCfr22Go-ggO68,3289
+sqlglot/dialects/singlestore.py,sha256=TyvnHVCfVRSFU5cXmNGUIQiOj7ma1dIT8_EeGZmEP3E,29237
+sqlglot/dialects/snowflake.py,sha256=iIBtw6FFgkyksGXiNagirQ8rl1SFf_Vu5mtpEVh7sx0,70487
 sqlglot/dialects/spark.py,sha256=hTumyd46Cc3HEl9KvlTla2eq_NKBI3w5Jis3FeMt_R8,8886
 sqlglot/dialects/spark2.py,sha256=aCwPqLduLRSUSPtbI1VtBjydK6haKgEy3iahmueGRo4,14742
 sqlglot/dialects/sqlite.py,sha256=XIDmiNTswWcrDwlFm8gOODCrJ_rPmXQKkm9U_-YAlVs,13183
@@ -60,7 +60,7 @@ sqlglot/optimizer/__init__.py,sha256=FdAvVz6rQLLkiiH21-SD4RxB5zS3WDeU-s03PZkJ-F4
 sqlglot/optimizer/annotate_types.py,sha256=mEhUmD6CBZ1HIgYJMvfMTIivoB-6nKHiDAvoktobocM,25025
 sqlglot/optimizer/canonicalize.py,sha256=RJpUbWDudjknRMtO_Kf8MGZ5Hv1twpPWac2u5kpV4Vw,7719
 sqlglot/optimizer/eliminate_ctes.py,sha256=fUBM0RUnPrm2sYptEWBux98B7fcx7W-BM1zVqfgDz9c,1448
-sqlglot/optimizer/eliminate_joins.py,sha256=5Whliegc7U8BnS6tlrl9wkeAgyP1NpgCCAPxChHzFfw,5874
+sqlglot/optimizer/eliminate_joins.py,sha256=2iYtG93aJGxvURqm1BVPosrnnnQ_IXI14RcD4pM8eHc,5942
 sqlglot/optimizer/eliminate_subqueries.py,sha256=sAB_Pk94_n2n1PIaZ2Mc3M-n2TV-JmjjaomaY14u0Og,6292
 sqlglot/optimizer/isolate_table_selects.py,sha256=_8rIKVMoL7eY3rrJsmgIdTRvfmBSLUxeHg42q1JW990,1464
 sqlglot/optimizer/merge_subqueries.py,sha256=lg6Is78nUM2MbqbRjE6xapgErIO-5pteBE74Qh3z4Zk,15211
@@ -73,11 +73,11 @@ sqlglot/optimizer/pushdown_projections.py,sha256=7NoK5NAUVYVhs0YnYyo6WuXfaO-BShS
 sqlglot/optimizer/qualify.py,sha256=oAPfwub7dEkrlCrsptcJWpLya4BgKhN6M5SwIs_86LY,4002
 sqlglot/optimizer/qualify_columns.py,sha256=epPE7HjnJ1yQCmy_QTzsjze7uM79BNsvzBem3gx4L3Q,43275
 sqlglot/optimizer/qualify_tables.py,sha256=rRo0rXMMDAloG_ut7nGPtIO3e__ooM2PqShxWECKQbo,6965
-sqlglot/optimizer/scope.py,sha256=HI3TZ4VWTgM6_x8k5ClA0lA0xidaKv4xgn8iGERJRjk,30824
+sqlglot/optimizer/scope.py,sha256=T6iVYnYwubt-WB1BOFsFYdJ-D7WtWZGL37SuCRQK23s,31154
 sqlglot/optimizer/simplify.py,sha256=-_yus42OYwqjQ9a2TSGhtG2G0pSkInUry1z7hEMz2pY,51062
 sqlglot/optimizer/unnest_subqueries.py,sha256=kzWUVDlxs8z9nmRx-8U-pHXPtVZhEIwkKqmKhr2QLvc,10908
-sqlglot-27.4.1.dist-info/licenses/LICENSE,sha256=AI3__mHZfOtzY3EluR_pIYBm3_pE7TbVx7qaHxoZ114,1065
-sqlglot-27.4.1.dist-info/METADATA,sha256=QgRU7ePRB-jDv1RMJMz1ey_5cK8TZqrmeJ5XKosvD7o,20731
-sqlglot-27.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sqlglot-27.4.1.dist-info/top_level.txt,sha256=5kRskCGA_gVADF9rSfSzPdLHXqvfMusDYeHePfNY2nQ,8
-sqlglot-27.4.1.dist-info/RECORD,,
+sqlglot-27.5.1.dist-info/licenses/LICENSE,sha256=p1Yk0B4oa0l8Rh-_dYyy75d8spjPd_vTloXfz4FWxys,1065
+sqlglot-27.5.1.dist-info/METADATA,sha256=qGmWTwLA19LsBnKSh45sCcekBfpbQaHm4ql4xe9dA3I,19437
+sqlglot-27.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sqlglot-27.5.1.dist-info/top_level.txt,sha256=5kRskCGA_gVADF9rSfSzPdLHXqvfMusDYeHePfNY2nQ,8
+sqlglot-27.5.1.dist-info/RECORD,,

{sqlglot-27.4.1.dist-info → sqlglot-27.5.1.dist-info}/licenses/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Toby Mao
+Copyright (c) 2025 Toby Mao
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal