Add alias tests

diff --git a/test/sql/test_cte.py b/test/sql/test_cte.py
index 4d6f9ffa87bb118178184a1c45fa68d6d7bc27d4..5de042c2bb19dc64e939bf239aaea1323a6639ed 100644 (file)
--- a/test/sql/test_cte.py
+++ b/test/sql/test_cte.py
@@ -1740,6 +1740,24 @@ class NestingCTETest(fixtures.TestBase, AssertsCompiledSQL):
             "SELECT cte.outer_cte FROM cte",
         )
 
+    def test_select_with_aliased_nesting_cte_in_cte(self):
+        nesting_cte = (
+            select(literal(1).label("inner_cte"))
+            .cte("nesting", nesting=True)
+            .alias("aliased_nested")
+        )
+        stmt = select(
+            select(nesting_cte.c.inner_cte.label("outer_cte")).cte("cte")
+        )
+
+        self.assert_compile(
+            stmt,
+            "WITH cte AS (WITH nesting AS (SELECT :param_1 AS inner_cte) "
+            "SELECT aliased_nested.inner_cte AS outer_cte "
+            "FROM nesting AS aliased_nested) "
+            "SELECT cte.outer_cte FROM cte",
+        )
+
     def test_nesting_cte_in_cte_with_same_name(self):
         nesting_cte = select(literal(1).label("inner_cte")).cte(
             "some_cte", nesting=True
@@ -1923,13 +1941,13 @@ class NestingCTETest(fixtures.TestBase, AssertsCompiledSQL):
         )
 
     def test_recursive_nesting_cte_in_cte(self):
-        nesting_cte = select(literal(1).label("inner_cte")).cte(
+        rec_root = select(literal(1).label("inner_cte")).cte(
             "nesting", recursive=True, nesting=True
         )
-        rec_part = select(nesting_cte.c.inner_cte).where(
-            nesting_cte.c.inner_cte == literal(1)
+        rec_part = select(rec_root.c.inner_cte).where(
+            rec_root.c.inner_cte == literal(1)
         )
-        nesting_cte = nesting_cte.union(rec_part)
+        nesting_cte = rec_root.union(rec_part)
 
         stmt = select(
             select(nesting_cte.c.inner_cte.label("outer_cte")).cte("cte")
@@ -1945,6 +1963,82 @@ class NestingCTETest(fixtures.TestBase, AssertsCompiledSQL):
             "SELECT cte.outer_cte FROM cte",
         )
 
+    def test_anon_recursive_nesting_cte_in_cte(self):
+        rec_root = (
+            select(literal(1).label("inner_cte"))
+            .cte("nesting", recursive=True, nesting=True)
+            .alias()
+        )
+        rec_part = select(rec_root.c.inner_cte).where(
+            rec_root.c.inner_cte == literal(1)
+        )
+        nesting_cte = rec_root.union(rec_part)
+
+        stmt = select(
+            select(nesting_cte.c.inner_cte.label("outer_cte")).cte("cte")
+        )
+
+        self.assert_compile(
+            stmt,
+            "WITH cte AS (WITH RECURSIVE anon_1(inner_cte) AS "
+            "(SELECT :param_1 AS inner_cte UNION "
+            "SELECT anon_1.inner_cte AS inner_cte FROM anon_1 "
+            "WHERE anon_1.inner_cte = :param_2) "
+            "SELECT anon_1.inner_cte AS outer_cte FROM anon_1) "
+            "SELECT cte.outer_cte FROM cte",
+        )
+
+    def test_fully_aliased_recursive_nesting_cte_in_cte(self):
+        rec_root = (
+            select(literal(1).label("inner_cte"))
+            .cte("nesting", recursive=True, nesting=True)
+            .alias("aliased_nesting")
+        )
+        rec_part = select(rec_root.c.inner_cte).where(
+            rec_root.c.inner_cte == literal(1)
+        )
+        nesting_cte = rec_root.union(rec_part)
+
+        stmt = select(
+            select(nesting_cte.c.inner_cte.label("outer_cte")).cte("cte")
+        )
+
+        self.assert_compile(
+            stmt,
+            "WITH cte AS (WITH RECURSIVE aliased_nesting(inner_cte) AS "
+            "(SELECT :param_1 AS inner_cte UNION "
+            "SELECT aliased_nesting.inner_cte AS inner_cte "
+            "FROM aliased_nesting "
+            "WHERE aliased_nesting.inner_cte = :param_2) "
+            "SELECT aliased_nesting.inner_cte AS outer_cte "
+            "FROM aliased_nesting) "
+            "SELECT cte.outer_cte FROM cte",
+        )
+
+    def test_aliased_recursive_nesting_cte_in_cte(self):
+        rec_root = select(literal(1).label("inner_cte")).cte(
+            "nesting", recursive=True, nesting=True
+        )
+        rec_part = select(rec_root.c.inner_cte).where(
+            rec_root.c.inner_cte == literal(1)
+        )
+        nesting_cte = rec_root.union(rec_part).alias("aliased_nesting")
+
+        stmt = select(
+            select(nesting_cte.c.inner_cte.label("outer_cte")).cte("cte")
+        )
+
+        self.assert_compile(
+            stmt,
+            "WITH cte AS (WITH RECURSIVE nesting(inner_cte) AS "
+            "(SELECT :param_1 AS inner_cte UNION "
+            "SELECT nesting.inner_cte AS inner_cte FROM nesting "
+            "WHERE nesting.inner_cte = :param_2) "
+            "SELECT aliased_nesting.inner_cte AS outer_cte "
+            "FROM nesting AS aliased_nesting) "
+            "SELECT cte.outer_cte FROM cte",
+        )
+
     def test_same_nested_cte_is_not_generated_twice(self):
         # Same = name and query
         nesting_cte_used_twice = select(literal(1).label("inner_cte_1")).cte(
@@ -2192,24 +2286,3 @@ class NestingCTETest(fixtures.TestBase, AssertsCompiledSQL):
             " WHERE should_continue.val != true))"
             " SELECT recursive_cte.the_value FROM recursive_cte",
         )
-
-    def test_recursive_cte_w_union_aliased(self):
-        nesting_cte = select(literal(1).label("inner_cte")).cte(
-            "nesting", recursive=True, nesting=True
-        )
-        nesting_cte_a = nesting_cte.alias()
-        nesting_cte = nesting_cte.union(
-            select(nesting_cte_a.c.inner_cte).where(
-                nesting_cte_a.c.inner_cte == literal(1)
-            )
-        )
-
-        stmt = select(nesting_cte.c.inner_cte)
-        self.assert_compile(
-            stmt,
-            "WITH RECURSIVE nesting(inner_cte) AS "
-            "(SELECT :param_1 AS inner_cte UNION "
-            "SELECT anon_1.inner_cte AS inner_cte FROM nesting AS anon_1 "
-            "WHERE anon_1.inner_cte = :param_2) "
-            "SELECT nesting.inner_cte FROM nesting",
-        )