sqlglot 26.27.1__py3-none-any.whl → 26.28.1__py3-none-any.whl

sqlglot/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '26.27.1'
-__version_tuple__ = version_tuple = (26, 27, 1)
+__version__ = version = '26.28.1'
+__version_tuple__ = version_tuple = (26, 28, 1)

sqlglot/expressions.py

@@ -51,8 +51,8 @@ class _Expression(type):
     def __new__(cls, clsname, bases, attrs):
         klass = super().__new__(cls, clsname, bases, attrs)
 
-        # When an Expression class is created, its key is automatically set to be
-        # the lowercase version of the class' name.
+        # When an Expression class is created, its key is automatically set
+        # to be the lowercase version of the class' name.
         klass.key = clsname.lower()
 
         # This is so that docstrings are not inherited in pdoc

sqlglot/optimizer/scope.py

@@ -758,6 +758,8 @@ def _traverse_tables(scope):
             expressions.extend(join.this for join in expression.args.get("joins") or [])
             continue
 
+        child_scope = None
+
         for child_scope in _traverse_scope(
             scope.branch(
                 expression,
@@ -775,8 +777,9 @@ def _traverse_tables(scope):
             sources[expression.alias] = child_scope
 
         # append the final child_scope yielded
-        scopes.append(child_scope)
-        scope.table_scopes.append(child_scope)
+        if child_scope:
+            scopes.append(child_scope)
+            scope.table_scopes.append(child_scope)
 
     scope.sources.update(sources)
 

sqlglot/parser.py

@@ -932,13 +932,14 @@ class Parser(metaclass=_Parser):
 
     PIPE_SYNTAX_TRANSFORM_PARSERS = {
         "SELECT": lambda self, query: self._parse_pipe_syntax_select(query),
-        "WHERE": lambda self, query: self._parse_pipe_syntax_where(query),
+        "WHERE": lambda self, query: query.where(self._parse_where(), copy=False),
         "ORDER BY": lambda self, query: query.order_by(
             self._parse_order(), append=False, copy=False
         ),
         "LIMIT": lambda self, query: self._parse_pipe_syntax_limit(query),
-        "OFFSET": lambda self, query: query.offset(self._parse_offset(), copy=False),
         "AGGREGATE": lambda self, query: self._parse_pipe_syntax_aggregate(query),
+        "PIVOT": lambda self, query: self._parse_pipe_syntax_pivot(query),
+        "UNPIVOT": lambda self, query: self._parse_pipe_syntax_pivot(query),
     }
 
     PROPERTY_PARSERS: t.Dict[str, t.Callable] = {
@@ -8327,40 +8328,33 @@ class Parser(metaclass=_Parser):
         expression.update_positions(token)
         return expression
 
-    def _build_pipe_cte(self, query: exp.Query, expressions: t.List[exp.Expression]) -> exp.Query:
-        if query.selects:
-            self._pipe_cte_counter += 1
-            new_cte = f"__tmp{self._pipe_cte_counter}"
-
-            # For `exp.Select`, generated CTEs are attached to its `with`
-            # For `exp.SetOperation`, generated CTEs are attached to the `with` of its LHS, accessed via `this`
-            with_ = (
-                query.args.get("with")
-                if isinstance(query, exp.Select)
-                else query.this.args.get("with")
-            )
-            ctes = with_.pop() if with_ else None
+    def _build_pipe_cte(self, query: exp.Query, expressions: t.List[exp.Expression]) -> exp.Select:
+        if not query.selects:
+            query = query.select("*", copy=False)
+
+        self._pipe_cte_counter += 1
+        new_cte = f"__tmp{self._pipe_cte_counter}"
 
-            new_select = exp.select(*expressions, copy=False).from_(new_cte, copy=False)
-            if ctes:
-                new_select.set("with", ctes)
+        with_ = query.args.get("with")
+        ctes = with_.pop() if with_ else None
 
-            return new_select.with_(new_cte, as_=query, copy=False)
+        new_select = exp.select(*expressions, copy=False).from_(new_cte, copy=False)
+        if ctes:
+            new_select.set("with", ctes)
 
-        return query.select(*expressions, copy=False)
+        return new_select.with_(new_cte, as_=query, copy=False)
 
-    def _parse_pipe_syntax_select(self, query: exp.Query) -> exp.Query:
+    def _parse_pipe_syntax_select(self, query: exp.Select) -> exp.Select:
         select = self._parse_select()
-        if isinstance(select, exp.Select):
-            return self._build_pipe_cte(query, select.expressions)
+        if not select:
+            return query
 
-        return query
+        if not query.selects:
+            return self._build_pipe_cte(query.select(*select.expressions), [exp.Star()])
 
-    def _parse_pipe_syntax_where(self, query: exp.Query) -> exp.Query:
-        where = self._parse_where()
-        return query.where(where, copy=False)
+        return self._build_pipe_cte(query, select.expressions)
 
-    def _parse_pipe_syntax_limit(self, query: exp.Query) -> exp.Query:
+    def _parse_pipe_syntax_limit(self, query: exp.Select) -> exp.Select:
         limit = self._parse_limit()
         offset = self._parse_offset()
         if limit:
@@ -8371,6 +8365,7 @@ class Parser(metaclass=_Parser):
             curr_offset = query.args.get("offset")
             curr_offset = curr_offset.expression.to_py() if curr_offset else 0
             query.offset(exp.Literal.number(curr_offset + offset.expression.to_py()), copy=False)
+
         return query
 
     def _parse_pipe_syntax_aggregate_fields(self) -> t.Optional[exp.Expression]:
@@ -8386,8 +8381,8 @@ class Parser(metaclass=_Parser):
         return this
 
     def _parse_pipe_syntax_aggregate_group_order_by(
-        self, query: exp.Query, group_by_exists: bool = True
-    ) -> exp.Query:
+        self, query: exp.Select, group_by_exists: bool = True
+    ) -> exp.Select:
         expr = self._parse_csv(self._parse_pipe_syntax_aggregate_fields)
         aggregates_or_groups, orders = [], []
         for element in expr:
@@ -8400,45 +8395,46 @@ class Parser(metaclass=_Parser):
                 this = element
             aggregates_or_groups.append(this)
 
-        if group_by_exists and isinstance(query, exp.Select):
+        if group_by_exists:
             query = query.select(*aggregates_or_groups, copy=False).group_by(
                 *[projection.args.get("alias", projection) for projection in aggregates_or_groups],
                 copy=False,
             )
         else:
-            query = query.select(*aggregates_or_groups, append=False, copy=False)
+            query = query.select(*aggregates_or_groups, copy=False)
 
         if orders:
             return query.order_by(*orders, append=False, copy=False)
 
         return query
 
-    def _parse_pipe_syntax_aggregate(self, query: exp.Query) -> exp.Query:
+    def _parse_pipe_syntax_aggregate(self, query: exp.Select) -> exp.Select:
         self._match_text_seq("AGGREGATE")
         query = self._parse_pipe_syntax_aggregate_group_order_by(query, group_by_exists=False)
 
         if self._match(TokenType.GROUP_BY) or (
             self._match_text_seq("GROUP", "AND") and self._match(TokenType.ORDER_BY)
         ):
-            return self._parse_pipe_syntax_aggregate_group_order_by(query)
+            query = self._parse_pipe_syntax_aggregate_group_order_by(query)
 
-        return query
+        return self._build_pipe_cte(query, [exp.Star()])
 
     def _parse_pipe_syntax_set_operator(
         self, query: t.Optional[exp.Query]
-    ) -> t.Optional[exp.Query]:
+    ) -> t.Optional[exp.Select]:
         first_setop = self.parse_set_operation(this=query)
 
         if not first_setop or not query:
             return None
 
-        if not query.selects:
-            query.select("*", copy=False)
-
-        this = first_setop.this.pop()
+        first_setop.this.pop()
         distinct = first_setop.args.pop("distinct")
         setops = [first_setop.expression.pop(), *self._parse_expressions()]
 
+        query = self._build_pipe_cte(query, [exp.Star()])
+        with_ = query.args.get("with")
+        ctes = with_.pop() if with_ else None
+
         if isinstance(first_setop, exp.Union):
             query = query.union(*setops, distinct=distinct, copy=False, **first_setop.args)
         elif isinstance(first_setop, exp.Except):
@@ -8446,22 +8442,41 @@ class Parser(metaclass=_Parser):
         else:
             query = query.intersect(*setops, distinct=distinct, copy=False, **first_setop.args)
 
-        return self._build_pipe_cte(
-            query, [projection.args.get("alias", projection) for projection in this.expressions]
-        )
+        query.set("with", ctes)
+
+        return self._build_pipe_cte(query, [exp.Star()])
+
+    def _parse_pipe_syntax_join(self, query: exp.Select) -> t.Optional[exp.Select]:
+        join = self._parse_join()
+        if not join:
+            return None
+
+        return query.join(join, copy=False)
 
-    def _parse_pipe_syntax_query(self, query: exp.Query) -> t.Optional[exp.Query]:
+    def _parse_pipe_syntax_pivot(self, query: exp.Select) -> exp.Select:
+        pivots = self._parse_pivots()
+        if not pivots:
+            return query
+
+        from_ = query.args.get("from")
+        if from_:
+            from_.this.set("pivots", pivots)
+
+        return self._build_pipe_cte(query, [exp.Star()])
+
+    def _parse_pipe_syntax_query(self, query: exp.Select) -> t.Optional[exp.Select]:
         while self._match(TokenType.PIPE_GT):
             start = self._curr
             parser = self.PIPE_SYNTAX_TRANSFORM_PARSERS.get(self._curr.text.upper())
             if not parser:
-                set_op_query = self._parse_pipe_syntax_set_operator(query)
-                if not set_op_query:
+                parsed_query = self._parse_pipe_syntax_set_operator(
+                    query
+                ) or self._parse_pipe_syntax_join(query)
+                if not parsed_query:
                     self._retreat(start)
                     self.raise_error(f"Unsupported pipe syntax operator: '{start.text.upper()}'.")
                     break
-
-                query = set_op_query
+                query = parsed_query
             else:
                 query = parser(self, query)
 

{sqlglot-26.27.1.dist-info → sqlglot-26.28.1.dist-info}/METADATA

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

{sqlglot-26.27.1.dist-info → sqlglot-26.28.1.dist-info}/RECORD

@@ -1,15 +1,15 @@
 sqlglot/__init__.py,sha256=za08rtdPh2v7dOpGdNomttlIVGgTrKja7rPd6sQwaTg,5391
 sqlglot/__main__.py,sha256=022c173KqxsiABWTEpUIq_tJUxuNiW7a7ABsxBXqvu8,2069
 sqlglot/_typing.py,sha256=-1HPyr3w5COlSJWqlgt8jhFk2dyMvBuvVBqIX1wyVCM,642
-sqlglot/_version.py,sha256=tGzmcwxazE8ZaUBuCO5phuigC0f9SB40km_TjYfnb90,515
+sqlglot/_version.py,sha256=lTxpjPlB8VNbv3452Opk2GFByRI5SLtHItxl9sne84Q,515
 sqlglot/diff.py,sha256=PtOllQMQa1Sw1-V2Y8eypmDqGujXYPaTOp_WLsWkAWk,17314
 sqlglot/errors.py,sha256=QNKMr-pzLUDR-tuMmn_GK6iMHUIVdb_YSJ_BhGEvuso,2126
-sqlglot/expressions.py,sha256=HspDzfH5_xnGPUvMPcwtNmIHaLbIj_NGmBWcvm8qIKw,242992
+sqlglot/expressions.py,sha256=oE7OmkFEstTWoPqM7yCls2I2JNyia8Spr-jVi3n77-A,242992
 sqlglot/generator.py,sha256=4iJ0BxkzinmosIhfhb34xjxaFpzw3Zo7fvmknaf5uRs,212432
 sqlglot/helper.py,sha256=9nZjFVRBtMKFC3EdzpDQ6jkazFO19po6BF8xHiNGZIo,15111
 sqlglot/jsonpath.py,sha256=dKdI3PNINNGimmSse2IIv-GbPN_3lXncXh_70QH7Lss,7664
 sqlglot/lineage.py,sha256=kXBDSErmZZluZx_kkrMj4MPEOAbkvcbX1tbOW7Bpl-U,15303
-sqlglot/parser.py,sha256=Jv02-ikrk8uqmYR4nxKgLUj704lIx1_ugXf-hShkZ8w,320240
+sqlglot/parser.py,sha256=TksM9cVq6bbbyM0sgglcOb-p6_1_Xk6EPIS2Buj-048,320530
 sqlglot/planner.py,sha256=ql7Li-bWJRcyXzNaZy_n6bQ6B2ZfunEIB8Ztv2xaxq4,14634
 sqlglot/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlglot/schema.py,sha256=13H2qKQs27EKdTpDLOvcNnSTDAUbYNKjWtJs4aQCSOA,20509
@@ -69,11 +69,11 @@ sqlglot/optimizer/pushdown_projections.py,sha256=7NoK5NAUVYVhs0YnYyo6WuXfaO-BShS
 sqlglot/optimizer/qualify.py,sha256=oAPfwub7dEkrlCrsptcJWpLya4BgKhN6M5SwIs_86LY,4002
 sqlglot/optimizer/qualify_columns.py,sha256=X2Iydssan_Fw84cd-mrzqxG3eRfRdpP6HVRofSbfHlg,40515
 sqlglot/optimizer/qualify_tables.py,sha256=5f5enBAh-bpNB9ewF97W9fx9h1TGXj1Ih5fncvH42sY,6486
-sqlglot/optimizer/scope.py,sha256=Fqz9GpBqO1GWzRAnqdflXXNz44ot_1JqVBC-DnYAU_E,30063
+sqlglot/optimizer/scope.py,sha256=lZWJsR1k-vx1VdxOn0yvbF_LcviXbK357WlrgOLXGEs,30123
 sqlglot/optimizer/simplify.py,sha256=S0Blqg5Mq2KRRWhWz-Eivch9sBjBhg9fRJA6EdBzj2g,50704
 sqlglot/optimizer/unnest_subqueries.py,sha256=kzWUVDlxs8z9nmRx-8U-pHXPtVZhEIwkKqmKhr2QLvc,10908
-sqlglot-26.27.1.dist-info/licenses/LICENSE,sha256=AI3__mHZfOtzY3EluR_pIYBm3_pE7TbVx7qaHxoZ114,1065
-sqlglot-26.27.1.dist-info/METADATA,sha256=R_0FXBifra90Z576tjTOsln1IrNAgj-vTzJL1-izN_4,20732
-sqlglot-26.27.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sqlglot-26.27.1.dist-info/top_level.txt,sha256=5kRskCGA_gVADF9rSfSzPdLHXqvfMusDYeHePfNY2nQ,8
-sqlglot-26.27.1.dist-info/RECORD,,
+sqlglot-26.28.1.dist-info/licenses/LICENSE,sha256=AI3__mHZfOtzY3EluR_pIYBm3_pE7TbVx7qaHxoZ114,1065
+sqlglot-26.28.1.dist-info/METADATA,sha256=ElrNZkPPdEmAmU1gVJgndWkFCWlhnYqLLkGB4562Bd4,20732
+sqlglot-26.28.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sqlglot-26.28.1.dist-info/top_level.txt,sha256=5kRskCGA_gVADF9rSfSzPdLHXqvfMusDYeHePfNY2nQ,8
+sqlglot-26.28.1.dist-info/RECORD,,