fix: OPTIONAL MATCH on denormalized schemas generates CTE + LEFT JOIN

Previously, OPTIONAL MATCH was completely dropped for denormalized schemas
where nodes are virtual (properties embedded in edge table). The Union
standalone node scan from MATCH was distributed into OPTIONAL MATCH
branches by UnionDistribution, losing LEFT JOIN semantics.

Three-layer fix:

1. union_distribution.rs: Skip distributing GraphRel over Union when
   the GraphRel is OPTIONAL and the Union is a denormalized standalone
   scan. Preserves the Union as an anchor for LEFT JOIN.

2. plan_builder.rs (GraphRel handler): When an OPTIONAL GraphRel has a
   Union-of-denormalized-nodes as left, render the Union as a CTE,
   use CTE as FROM, and LEFT JOIN the edge table with the correct
   from_id/node_id join condition.

3. plan_builder.rs (to_render_plan_with_ctx): Detect the pattern in
   GraphJoins-wrapped plans and delegate to the GraphRel handler,
   overlaying outer SELECT/GROUP BY/ORDER BY.

Also:
- plan_builder_helpers.rs: is_node_denormalized now handles Union
- plan_optimizer.rs: edge join preserved via from_id_column marker
- synthesize_denorm_optional_join_condition for CartesianProduct path

Generated SQL (still needs column reference refinement in follow-up):
```sql
WITH __denorm_scan_a AS (
  SELECT origin_code AS "code" FROM flights
  UNION DISTINCT
  SELECT dest_code AS "code" FROM flights
)
SELECT a.code, count(*) FROM __denorm_scan_a AS a
LEFT JOIN flights AS r ON a.code = r.origin_code
GROUP BY a.code
```

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: genezhang

src/clickhouse_query_generator/to_sql_query.rs

@@ -2507,6 +2507,13 @@ fn flatten_all_ctes(plan: &mut RenderPlan) {
 }
 
 pub fn render_plan_to_sql(mut plan: RenderPlan, _max_cte_depth: u32) -> String {
+    log::trace!(
+        "render_plan_to_sql: from={:?}, joins={}, union={}, ctes={}",
+        plan.from.0.as_ref().map(|f| &f.name),
+        plan.joins.0.len(),
+        plan.union.0.is_some(),
+        plan.ctes.0.len()
+    );
     // STEP 0: Flatten ALL CTEs to top level in dependency order.
     // CTEs are always a flat, linear chain — never nested inside other CTEs or union branches.
     flatten_all_ctes(&mut plan);
@@ -2548,6 +2555,10 @@ pub fn render_plan_to_sql(mut plan: RenderPlan, _max_cte_depth: u32) -> String {
 
         sort_joins_by_dependency(plan.joins.0, from_table.as_ref())
     };
+    log::trace!(
+        "render_plan_to_sql after sort_joins: joins={}",
+        plan.joins.0.len()
+    );
 
     // Also sort JOINs in UNION branches
     if let Some(ref mut union) = plan.union.0 {

src/query_planner/analyzer/union_distribution.rs

@@ -139,17 +139,43 @@ fn distribute_union_impl(plan: &LogicalPlan, depth: usize) -> LogicalPlan {
             let new_right = distribute_union_impl(&gr.right, depth + 1);
 
             // If left became Union after distribution, distribute GraphRel over it
+            // EXCEPTION: Skip when the GraphRel is OPTIONAL and the Union is a
+            // denormalized standalone node scan. Distribution would push the OPTIONAL
+            // MATCH edge into each Union branch, losing LEFT JOIN semantics (every
+            // flight row has airports, so no airport would appear "without flights").
             if let LogicalPlan::Union(union) = &new_left {
-                log::debug!(
-                    "🔀 UnionDistribution: distributing GraphRel '{}' over left Union ({} branches)",
-                    gr.alias,
-                    union.inputs.len()
-                );
-                let center = Arc::new(new_center);
-                let right = Arc::new(new_right);
-                return distribute_over_union(union, |branch| {
-                    LogicalPlan::GraphRel(graph_rel_with(gr, branch, center.clone(), right.clone()))
-                });
+                let is_optional_gr = gr.is_optional.unwrap_or(false);
+                let is_denorm_union = is_optional_gr
+                    && !union.inputs.is_empty()
+                    && union.inputs.iter().all(|input| {
+                        matches!(input.as_ref(), LogicalPlan::GraphNode(gn)
+                            if gn.is_denormalized
+                                || matches!(gn.input.as_ref(), LogicalPlan::ViewScan(vs) if vs.is_denormalized))
+                    });
+
+                if is_denorm_union {
+                    log::info!(
+                        "🔀 UnionDistribution: SKIPPING GraphRel '{}' distribution over denormalized OPTIONAL Union — preserving LEFT JOIN semantics",
+                        gr.alias
+                    );
+                    // Keep the Union as-is; wrap in GraphRel without distributing
+                } else {
+                    log::debug!(
+                        "🔀 UnionDistribution: distributing GraphRel '{}' over left Union ({} branches)",
+                        gr.alias,
+                        union.inputs.len()
+                    );
+                    let center = Arc::new(new_center);
+                    let right = Arc::new(new_right);
+                    return distribute_over_union(union, |branch| {
+                        LogicalPlan::GraphRel(graph_rel_with(
+                            gr,
+                            branch,
+                            center.clone(),
+                            right.clone(),
+                        ))
+                    });
+                }
             }
 
             // If right became Union after distribution, distribute GraphRel over it
@@ -195,20 +221,47 @@ fn distribute_union_impl(plan: &LogicalPlan, depth: usize) -> LogicalPlan {
                 });
             }
             // CP(Union(br0, br1), right) → Union(CP(br0, right), CP(br1, right))
+            // EXCEPTION: Skip distribution when:
+            // - The CartesianProduct is optional (OPTIONAL MATCH pattern)
+            // - The Union is a denormalized standalone node scan
+            // Distribution would push the OPTIONAL MATCH into each Union branch,
+            // losing LEFT JOIN semantics (every branch would scan the edge table
+            // directly, making all airports appear to have flights).
             if let LogicalPlan::Union(union) = &new_left {
-                log::debug!(
-                    "🔀 UnionDistribution: distributing CP over left Union ({} branches)",
-                    union.inputs.len()
-                );
-                let right = Arc::new(new_right);
-                return distribute_over_union(union, |branch| {
-                    LogicalPlan::CartesianProduct(CartesianProduct {
-                        left: branch,
-                        right: right.clone(),
-                        is_optional: cp.is_optional,
-                        join_condition: cp.join_condition.clone(),
-                    })
+                let is_denorm_union = union.inputs.iter().all(|input| {
+                    fn is_denorm_node(plan: &LogicalPlan) -> bool {
+                        match plan {
+                            LogicalPlan::GraphNode(gn) => {
+                                gn.is_denormalized
+                                    || matches!(gn.input.as_ref(), LogicalPlan::ViewScan(vs) if vs.is_denormalized)
+                            }
+                            _ => false,
+                        }
+                    }
+                    is_denorm_node(input)
                 });
+
+                if cp.is_optional && is_denorm_union {
+                    log::info!(
+                        "🔀 UnionDistribution: SKIPPING distribution of OPTIONAL CP over denormalized Union ({} branches) — preserving LEFT JOIN semantics",
+                        union.inputs.len()
+                    );
+                    // Don't distribute; keep the CartesianProduct intact
+                } else {
+                    log::debug!(
+                        "🔀 UnionDistribution: distributing CP over left Union ({} branches)",
+                        union.inputs.len()
+                    );
+                    let right = Arc::new(new_right);
+                    return distribute_over_union(union, |branch| {
+                        LogicalPlan::CartesianProduct(CartesianProduct {
+                            left: branch,
+                            right: right.clone(),
+                            is_optional: cp.is_optional,
+                            join_condition: cp.join_condition.clone(),
+                        })
+                    });
+                }
             }
 
             LogicalPlan::CartesianProduct(CartesianProduct {