sqlglot 26.27.1__tar.gz → 26.28.1__tar.gz

{sqlglot-26.27.1 → sqlglot-26.28.1}/CHANGELOG.md

@@ -1,6 +1,47 @@
 Changelog
 =========
 
+## [v26.27.0] - 2025-06-12
+### :boom: BREAKING CHANGES
+- due to [`ac6555b`](https://github.com/tobymao/sqlglot/commit/ac6555b4d6c162ef7b14b63307d01fd560138ea0) - preserve DIV binary operator, fixes [#5198](https://github.com/tobymao/sqlglot/pull/5198) *(PR [#5199](https://github.com/tobymao/sqlglot/pull/5199) by [@georgesittas](https://github.com/georgesittas))*:
+
+  preserve DIV binary operator, fixes #5198 (#5199)
+
+- due to [`dfdd84b`](https://github.com/tobymao/sqlglot/commit/dfdd84bbc50da70f40a17b39935f8171d961f7d2) - CTEs instead of subqueries for pipe syntax *(PR [#5205](https://github.com/tobymao/sqlglot/pull/5205) by [@geooo109](https://github.com/geooo109))*:
+
+  CTEs instead of subqueries for pipe syntax (#5205)
+
+- due to [`5f95299`](https://github.com/tobymao/sqlglot/commit/5f9529940d83e89704f7d25eda63cd73fdb503ae) - support multi-part (>3) dotted functions *(PR [#5211](https://github.com/tobymao/sqlglot/pull/5211) by [@georgesittas](https://github.com/georgesittas))*:
+
+  support multi-part (>3) dotted functions (#5211)
+
+- due to [`02afa2a`](https://github.com/tobymao/sqlglot/commit/02afa2a1941fc67086d50dffac2857262f1c3c4f) - Preserve quoting for UDT *(PR [#5216](https://github.com/tobymao/sqlglot/pull/5216) by [@VaggelisD](https://github.com/VaggelisD))*:
+
+  Preserve quoting for UDT (#5216)
+
+
+### :sparkles: New Features
+- [`c20f85e`](https://github.com/tobymao/sqlglot/commit/c20f85e3e171e502fc51f74894d3313f0ad61535) - **spark**: support ALTER ADD PARTITION *(PR [#5208](https://github.com/tobymao/sqlglot/pull/5208) by [@georgesittas](https://github.com/georgesittas))*
+  - :arrow_lower_right: *addresses issue [#5204](https://github.com/tobymao/sqlglot/issues/5204) opened by [@cosinequanon](https://github.com/cosinequanon)*
+
+### :bug: Bug Fixes
+- [`99bbae3`](https://github.com/tobymao/sqlglot/commit/99bbae370329c5f5cd132b711c714359cf96ba58) - **sqlite**: allow ALTER RENAME without COLUMN keyword fixes [#5195](https://github.com/tobymao/sqlglot/pull/5195) *(commit by [@georgesittas](https://github.com/georgesittas))*
+- [`ac6555b`](https://github.com/tobymao/sqlglot/commit/ac6555b4d6c162ef7b14b63307d01fd560138ea0) - **hive**: preserve DIV binary operator, fixes [#5198](https://github.com/tobymao/sqlglot/pull/5198) *(PR [#5199](https://github.com/tobymao/sqlglot/pull/5199) by [@georgesittas](https://github.com/georgesittas))*
+- [`d0eeb26`](https://github.com/tobymao/sqlglot/commit/d0eeb2639e771e8f8b6feabd41c65f16ed5a9829) - eliminate_join_marks has multiple issues fixes [#5188](https://github.com/tobymao/sqlglot/pull/5188) *(PR [#5189](https://github.com/tobymao/sqlglot/pull/5189) by [@snovik75](https://github.com/snovik75))*
+  - :arrow_lower_right: *fixes issue [#5188](https://github.com/tobymao/sqlglot/issues/5188) opened by [@snovik75](https://github.com/snovik75)*
+- [`dfdd84b`](https://github.com/tobymao/sqlglot/commit/dfdd84bbc50da70f40a17b39935f8171d961f7d2) - **parser**: CTEs instead of subqueries for pipe syntax *(PR [#5205](https://github.com/tobymao/sqlglot/pull/5205) by [@geooo109](https://github.com/geooo109))*
+- [`77e9d9a`](https://github.com/tobymao/sqlglot/commit/77e9d9a0269e2013379967cf2f46fbd79c036277) - **mysql**: properly parse STORED/VIRTUAL computed columns *(PR [#5210](https://github.com/tobymao/sqlglot/pull/5210) by [@georgesittas](https://github.com/georgesittas))*
+  - :arrow_lower_right: *fixes issue [#5203](https://github.com/tobymao/sqlglot/issues/5203) opened by [@mdebski](https://github.com/mdebski)*
+- [`5f95299`](https://github.com/tobymao/sqlglot/commit/5f9529940d83e89704f7d25eda63cd73fdb503ae) - **parser**: support multi-part (>3) dotted functions *(PR [#5211](https://github.com/tobymao/sqlglot/pull/5211) by [@georgesittas](https://github.com/georgesittas))*
+  - :arrow_lower_right: *fixes issue [#5200](https://github.com/tobymao/sqlglot/issues/5200) opened by [@mateuszpoleski](https://github.com/mateuszpoleski)*
+- [`02afa2a`](https://github.com/tobymao/sqlglot/commit/02afa2a1941fc67086d50dffac2857262f1c3c4f) - **postgres**: Preserve quoting for UDT *(PR [#5216](https://github.com/tobymao/sqlglot/pull/5216) by [@VaggelisD](https://github.com/VaggelisD))*
+  - :arrow_lower_right: *fixes issue [#5212](https://github.com/tobymao/sqlglot/issues/5212) opened by [@NickCrews](https://github.com/NickCrews)*
+- [`f37c0b1`](https://github.com/tobymao/sqlglot/commit/f37c0b1197321dd610648ce652a171ab063deeeb) - **snowflake**: ensure a standalone GET() expression can be parsed *(PR [#5219](https://github.com/tobymao/sqlglot/pull/5219) by [@georgesittas](https://github.com/georgesittas))*
+
+### :wrench: Chores
+- [`ad8a4e7`](https://github.com/tobymao/sqlglot/commit/ad8a4e73e1a9e4234f0b711163fb49630acf736c) - refactor join mark elimination to use is_correlated_subquery *(commit by [@georgesittas](https://github.com/georgesittas))*
+
+
 ## [v26.26.0] - 2025-06-09
 ### :boom: BREAKING CHANGES
 - due to [`434c45b`](https://github.com/tobymao/sqlglot/commit/434c45b547c3a5ea155dc8d7da2baab326eb6d4f) - improve support for ENDSWITH closes [#5170](https://github.com/tobymao/sqlglot/pull/5170) *(commit by [@georgesittas](https://github.com/georgesittas))*:
@@ -4840,3 +4881,4 @@ Changelog
 [v26.25.2]: https://github.com/tobymao/sqlglot/compare/v26.25.1...v26.25.2
 [v26.25.3]: https://github.com/tobymao/sqlglot/compare/v26.25.2...v26.25.3
 [v26.26.0]: https://github.com/tobymao/sqlglot/compare/v26.25.3...v26.26.0
+[v26.27.0]: https://github.com/tobymao/sqlglot/compare/v26.26.0...v26.27.0

{sqlglot-26.27.1 → sqlglot-26.28.1}/PKG-INFO

@@ -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 → sqlglot-26.28.1}/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-26.27.1 → sqlglot-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-26.27.1 → sqlglot-26.28.1}/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-26.27.1 → sqlglot-26.28.1}/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 → sqlglot-26.28.1}/sqlglot.egg-info/PKG-INFO

@@ -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 → sqlglot-26.28.1}/sqlglot.egg-info/SOURCES.txt

@@ -138,6 +138,7 @@ tests/dialects/test_hive.py
 tests/dialects/test_materialize.py
 tests/dialects/test_mysql.py
 tests/dialects/test_oracle.py
+tests/dialects/test_pipe_syntax.py
 tests/dialects/test_postgres.py
 tests/dialects/test_presto.py
 tests/dialects/test_prql.py

{sqlglot-26.27.1 → sqlglot-26.28.1}/tests/dialects/test_dialect.py

@@ -3504,222 +3504,3 @@ FROM subquery2""",
                     parse_one("SELECT 0xCC", read=read_dialect).sql(other_integer_dialects),
                     "SELECT 0xCC",
                 )
-
-    def test_pipe_syntax(self):
-        self.validate_identity("FROM x", "SELECT * FROM x")
-        self.validate_identity("FROM x |> SELECT x1, x2", "SELECT x1, x2 FROM x")
-        self.validate_identity(
-            "FROM x |> SELECT x1 as c1, x2 as c2",
-            "SELECT x1 AS c1, x2 AS c2 FROM x",
-        )
-        self.validate_identity(
-            "FROM x |> SELECT x1 + 1 as x1_a, x2 - 1 as x2_a |> WHERE x1_a > 1",
-            "SELECT x1 + 1 AS x1_a, x2 - 1 AS x2_a FROM x WHERE x1_a > 1",
-        )
-        self.validate_identity(
-            "FROM x |> SELECT x1 + 1 as x1_a, x2 - 1 as x2_a |> WHERE x1_a > 1 |> SELECT x2_a",
-            "WITH __tmp1 AS (SELECT x1 + 1 AS x1_a, x2 - 1 AS x2_a FROM x WHERE x1_a > 1) SELECT x2_a FROM __tmp1",
-        )
-        self.validate_identity(
-            "FROM x |> WHERE x1 > 0 OR x2 > 0 |> WHERE x3 > 1 AND x4 > 1 |> SELECT x1, x4",
-            "SELECT x1, x4 FROM x WHERE (x1 > 0 OR x2 > 0) AND (x3 > 1 AND x4 > 1)",
-        )
-        self.validate_identity(
-            "FROM x |> WHERE x1 > 1 |> WHERE x2 > 2 |> SELECT x1 as gt1, x2 as gt2",
-            "SELECT x1 AS gt1, x2 AS gt2 FROM x WHERE x1 > 1 AND x2 > 2",
-        )
-        self.validate_identity(
-            "FROM x |> WHERE x1 > 1 AND x2 > 2 |> SELECT x1 as gt1, x2 as gt2 |> SELECT gt1 * 2 + gt2 * 2 AS gt2_2",
-            "WITH __tmp1 AS (SELECT x1 AS gt1, x2 AS gt2 FROM x WHERE x1 > 1 AND x2 > 2) SELECT gt1 * 2 + gt2 * 2 AS gt2_2 FROM __tmp1",
-        )
-        self.validate_identity("FROM x |> ORDER BY x1", "SELECT * FROM x ORDER BY x1")
-        self.validate_identity(
-            "FROM x |> ORDER BY x1 |> ORDER BY x2", "SELECT * FROM x ORDER BY x2"
-        )
-        self.validate_identity(
-            "FROM x |> ORDER BY x1 |> WHERE x1 > 0 OR x1 != 1 |> ORDER BY x2 |> WHERE x2 > 0 AND x2 != 1 |> SELECT x1, x2",
-            "SELECT x1, x2 FROM x WHERE (x1 > 0 OR x1 <> 1) AND (x2 > 0 AND x2 <> 1) ORDER BY x2",
-        )
-        self.validate_identity(
-            "FROM x |> ORDER BY x1 |> WHERE x1 > 0 |> SELECT x1",
-            "SELECT x1 FROM x WHERE x1 > 0 ORDER BY x1",
-        )
-        self.validate_identity(
-            "FROM x |> WHERE x1 > 0 |> SELECT x1 |> ORDER BY x1",
-            "SELECT x1 FROM x WHERE x1 > 0 ORDER BY x1",
-        )
-        self.validate_identity(
-            "FROM x |> SELECT x1, x2, x3 |> ORDER BY x1 DESC NULLS FIRST, x2 ASC NULLS LAST, x3",
-            "SELECT x1, x2, x3 FROM x ORDER BY x1 DESC NULLS FIRST, x2 ASC NULLS LAST, x3",
-        )
-        for option in ("LIMIT 1", "OFFSET 2", "LIMIT 1 OFFSET 2"):
-            with self.subTest(f"Testing pipe syntax LIMIT and OFFSET option: {option}"):
-                self.validate_identity(f"FROM x |> {option}", f"SELECT * FROM x {option}")
-                self.validate_identity(f"FROM x |> {option}", f"SELECT * FROM x {option}")
-                self.validate_identity(
-                    f"FROM x |> {option} |> SELECT x1, x2 |> WHERE x1 > 0 |> WHERE x2 > 0  |> ORDER BY x1, x2 ",
-                    f"SELECT x1, x2 FROM x WHERE x1 > 0 AND x2 > 0 ORDER BY x1, x2 {option}",
-                )
-                self.validate_identity(
-                    f"FROM x |> SELECT x1, x2 |> WHERE x1 > 0 |> WHERE x2 > 0  |> ORDER BY x1, x2 |> {option}",
-                    f"SELECT x1, x2 FROM x WHERE x1 > 0 AND x2 > 0 ORDER BY x1, x2 {option}",
-                )
-        self.validate_identity(
-            "FROM x |> SELECT x1, x2 |> LIMIT 2 |> LIMIT 4", "SELECT x1, x2 FROM x LIMIT 2"
-        )
-        self.validate_identity(
-            "FROM x |> SELECT x1, x2 |> LIMIT 2 OFFSET 2 |> LIMIT 4 OFFSET 2",
-            "SELECT x1, x2 FROM x LIMIT 2 OFFSET 4",
-        )
-        self.validate_identity(
-            "FROM x |> AGGREGATE SUM(x1), MAX(x2), MIN(x3)",
-            "SELECT SUM(x1), MAX(x2), MIN(x3) FROM x",
-        )
-        self.validate_identity(
-            "FROM x |> AGGREGATE SUM(x1) AS s_x1 |> SELECT s_x1",
-            "WITH __tmp1 AS (SELECT SUM(x1) AS s_x1 FROM x) SELECT s_x1 FROM __tmp1",
-        )
-        self.validate_identity(
-            "FROM x |> AGGREGATE SUM(x1), MAX(x2), MIN(x3) GROUP BY x4, x5",
-            "SELECT SUM(x1), MAX(x2), MIN(x3), x4, x5 FROM x GROUP BY x4, x5",
-        )
-        self.validate_identity(
-            "FROM x |> AGGREGATE SUM(x1), MAX(x2), MIN(x3) GROUP BY x4 AS a_x4, x5 AS a_x5",
-            "SELECT SUM(x1), MAX(x2), MIN(x3), x4 AS a_x4, x5 AS a_x5 FROM x GROUP BY a_x4, a_x5",
-        )
-        self.validate_identity(
-            "FROM x |> AGGREGATE SUM(x1) as s_x1 GROUP BY x1 |> SELECT s_x1, x1 as ss_x1",
-            "WITH __tmp1 AS (SELECT SUM(x1) AS s_x1, x1 FROM x GROUP BY x1) SELECT s_x1, x1 AS ss_x1 FROM __tmp1",
-        )
-        self.validate_identity(
-            "FROM x |> AGGREGATE SUM(x1) GROUP", "SELECT SUM(x1) AS GROUP FROM x"
-        )
-        for order_option in ("ASC", "DESC", "ASC NULLS LAST", "DESC NULLS FIRST"):
-            with self.subTest(f"Testing pipe syntax AGGREGATE for order option: {order_option}"):
-                self.validate_all(
-                    f"SELECT SUM(x1) AS x_s FROM x ORDER BY x_s {order_option}",
-                    read={
-                        "bigquery": f"FROM x |> AGGREGATE SUM(x1) AS x_s {order_option}",
-                    },
-                )
-                self.validate_all(
-                    f"SELECT SUM(x1) AS x_s, x1 AS g_x1 FROM x GROUP BY g_x1 ORDER BY x_s {order_option}",
-                    read={
-                        "bigquery": f"FROM x |> AGGREGATE SUM(x1) AS x_s {order_option} GROUP BY x1 AS g_x1",
-                    },
-                )
-            with self.subTest(
-                f"Testing pipe syntax AGGREGATE with GROUP AND ORDER BY for order option: {order_option}"
-            ):
-                self.validate_all(
-                    f"WITH __tmp1 AS (SELECT SUM(x1) AS x_s, x1 AS g_x1 FROM x GROUP BY g_x1 ORDER BY g_x1 {order_option}) SELECT g_x1, x_s FROM __tmp1",
-                    read={
-                        "bigquery": f"FROM x |> AGGREGATE SUM(x1) AS x_s GROUP AND ORDER BY x1 AS g_x1 {order_option} |> SELECT g_x1, x_s",
-                    },
-                )
-
-            for op_operator in (
-                "UNION ALL",
-                "UNION DISTINCT",
-                "INTERSECT DISTINCT",
-                "EXCEPT DISTINCT",
-            ):
-                with self.subTest(f"Testing pipe syntax SET OPERATORS: {op_operator}"):
-                    self.validate_all(
-                        f"FROM x|> {op_operator} (SELECT y1 FROM y), (SELECT z1 FROM z)",
-                        write={
-                            "bigquery": f"WITH __tmp1 AS (SELECT * FROM x {op_operator} (SELECT y1 FROM y) {op_operator} (SELECT z1 FROM z)) SELECT * FROM __tmp1",
-                        },
-                    )
-
-            for op_prefix in ("LEFT OUTER", "FULL OUTER"):
-                for op_operator in (
-                    "UNION ALL",
-                    "UNION DISTINCT",
-                    "INTERSECT DISTINCT",
-                    "EXCEPT DISTINCT",
-                ):
-                    for suffix_operator in ("BY NAME", "CORRESPONDING"):
-                        with self.subTest(
-                            f"Testing pipe syntax SET OPERATORS: {op_prefix} {op_operator} {suffix_operator}"
-                        ):
-                            self.validate_all(
-                                f"FROM x|> SELECT x1, x2 FROM x |> {op_prefix} {op_operator} {suffix_operator} (SELECT y1, y2 FROM y), (SELECT z1, z2 FROM z)",
-                                write={
-                                    "bigquery": f"WITH __tmp1 AS (SELECT x1, x2 FROM x {op_prefix} {op_operator} BY NAME (SELECT y1, y2 FROM y) {op_prefix} {op_operator} BY NAME (SELECT z1, z2 FROM z)) SELECT x1, x2 FROM __tmp1",
-                                },
-                            )
-
-            self.validate_identity(
-                "FROM d.x |> SELECT x.x1 |> UNION (SELECT 2 AS a1) |> SELECT x1 |> UNION (SELECT 3 as a2) |> SELECT x1 |> WHERE x1 > 100",
-                """WITH __tmp1 AS (
-  SELECT
-    x.x1
-  FROM d.x
-  UNION
-  (
-    SELECT
-      2 AS a1
-  )
-), __tmp2 AS (
-  SELECT
-    x.x1
-  FROM __tmp1
-), __tmp3 AS (
-  SELECT
-    x1
-  FROM __tmp2
-  UNION
-  (
-    SELECT
-      3 AS a2
-  )
-), __tmp4 AS (
-  SELECT
-    x1
-  FROM __tmp3
-)
-SELECT
-  x1
-FROM __tmp4
-WHERE
-  x1 > 100""",
-                pretty=True,
-            )
-
-        self.validate_identity(
-            "FROM c.x |> UNION ALL (SELECT 2 AS a1, '2' as a2) |> AGGREGATE AVG(x1) as m_x1 |> SELECT * |> UNION ALL (SELECT y1 FROM c.y) |> SELECT m_x1",
-            """WITH __tmp1 AS (
-  SELECT
-    *
-  FROM c.x
-  UNION ALL
-  (
-    SELECT
-      2 AS a1,
-      '2' AS a2
-  )
-), __tmp2 AS (
-  SELECT
-    AVG(x1) AS m_x1
-  FROM __tmp1
-), __tmp3 AS (
-  SELECT
-    *
-  FROM __tmp2
-  UNION ALL
-  (
-    SELECT
-      y1
-    FROM c.y
-  )
-), __tmp4 AS (
-  SELECT
-    *
-  FROM __tmp3
-)
-SELECT
-  m_x1
-FROM __tmp4""",
-            pretty=True,
-        )