Handle CTE name collisions between user and generated CTEs

Two changes:

1. post_process path: remove CTE hoisting entirely. Inner SQL (with
   CTEs) is placed directly in the subquery position. CTEs inside
   subqueries are valid in all target databases and naturally scoped,
   so name collisions with post_process CTEs cannot occur.

2. Root semantic + user CTEs: detect name collisions between user CTEs
   and generated CTEs, raising a clear error instead of producing
   invalid SQL. Walk-based renaming was too aggressive (renamed user
   CTE references inside filter subqueries).

Author: nicosuave

sidemantic/core/semantic_layer.py

@@ -552,30 +552,10 @@ def compile(
             if last_line.startswith("-- sidemantic:"):
                 stripped = "\n".join(stripped.split("\n")[:-1])
 
-            # If inner SQL starts with WITH (CTEs), hoist them outside
-            # the subquery position so the SQL is valid.
-            if stripped.lstrip().upper().startswith("WITH "):
-                import sqlglot
-
-                target_dialect = dialect or self.dialect
-                parsed_inner = sqlglot.parse_one(stripped, dialect=target_dialect)
-                inner_with = parsed_inner.args.get("with")
-                if inner_with:
-                    parsed_inner.set("with", None)
-                    body = parsed_inner.sql(dialect=target_dialect)
-
-                    # Substitute body into post_process, then merge CTEs
-                    outer_sql = post_process.replace("{inner}", body)
-                    outer_parsed = sqlglot.parse_one(outer_sql, dialect=target_dialect)
-                    outer_with = outer_parsed.args.get("with")
-                    if outer_with:
-                        # Prepend inner CTEs before outer CTEs
-                        merged = list(inner_with.expressions) + list(outer_with.expressions)
-                        outer_with.set("expressions", merged)
-                    else:
-                        outer_parsed.set("with", inner_with)
-                    return outer_parsed.sql(dialect=target_dialect)
-
+            # Inner SQL (including any CTEs) is placed directly in the
+            # subquery position. CTEs inside subqueries are valid SQL in
+            # all target databases and naturally scoped, avoiding name
+            # collisions with CTEs in the post_process SQL.
             return post_process.replace("{inner}", stripped)
 
         return inner_sql

sidemantic/sql/query_rewriter.py

@@ -1876,6 +1876,15 @@ def _rewrite_with_ctes_or_subqueries(self, parsed: exp.Select) -> str:
                 rewritten = sqlglot.parse_one(rewritten_sql, dialect=self.dialect)
                 gen_with = rewritten.args.get("with")
                 if gen_with:
+                    # Check for CTE name collisions between user and generated CTEs
+                    user_names = {cte.alias for cte in original_with.expressions}
+                    for gen_cte in gen_with.expressions:
+                        if gen_cte.alias in user_names:
+                            raise ValueError(
+                                f"CTE name '{gen_cte.alias}' conflicts with an internally "
+                                f"generated name. Please choose a different CTE name."
+                            )
+
                     user_ctes = [cte.copy() for cte in original_with.expressions]
                     gen_with.set("expressions", user_ctes + list(gen_with.expressions))
                     # Preserve WITH RECURSIVE from the original query

tests/queries/test_sql_rewriter.py

@@ -1433,3 +1433,35 @@ def test_post_process_with_own_ctes(semantic_layer):
 
     assert len(rows) >= 1
     assert all(row["revenue"] >= 200 for row in rows)
+
+
+def test_post_process_cte_name_collision(semantic_layer):
+    """post_process CTE with same name as generated CTE doesn't collide."""
+    result = semantic_layer.query(
+        metrics=["orders.revenue"],
+        dimensions=["orders.status"],
+        post_process="""
+            WITH orders_cte AS (SELECT 'custom' AS source)
+            SELECT sq.*, oc.source
+            FROM ({inner}) sq
+            CROSS JOIN orders_cte oc
+        """,
+    )
+    rows = _rows(result)
+
+    assert len(rows) >= 1
+    assert all(row["source"] == "custom" for row in rows)
+
+
+def test_root_semantic_cte_name_collision(semantic_layer):
+    """User CTE with same name as generated CTE raises a clear error."""
+    sql = """
+        WITH orders_cte AS (
+            SELECT 'completed' AS status
+        )
+        SELECT orders.revenue
+        FROM orders
+        WHERE orders.status IN (SELECT status FROM orders_cte)
+    """
+    with pytest.raises(ValueError, match="conflicts with an internally generated name"):
+        semantic_layer.sql(sql)