fix: Track C empty branch detection in UNION assembly

- Add is_empty_or_filtered_branch() helper to detect both explicit (LogicalPlan::Empty)
  and implicit (GraphRel{labels: None}) empty branches
- Update UNION assembly to filter out empty branches before creating UNION
- Add safety guards in analyzer phases (projection_tagging, graph_context, etc.)
  to skip processing when labels are None
- Fixes Neo4j Browser property key queries that filter to 0 relationship types

Resolves incomplete Track C implementation from PR #67
Tested: UNION with one empty branch now works correctly

Author: genezhang

investigate_empty_branch.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+"""
+Bug #2 Investigation: Trace where empty branch error occurs
+"""
+import requests
+
+# Minimal test case: UNION with empty relationship branch
+query = """
+USE social_benchmark
+MATCH (n) WHERE n.country IS NOT NULL 
+RETURN n.country
+UNION ALL 
+MATCH ()-[r]-() WHERE r.country IS NOT NULL 
+RETURN r.country
+"""
+
+print("="*80)
+print("Bug #2: Empty Branch Investigation")
+print("="*80)
+print("\nQuery:")
+print(query)
+print("\nExpected: Return nodes with country, skip relationships (none have country)")
+print("Actual: Will error with 'Relationship type '' not found'")
+print("\nSending query...")
+
+r = requests.post("http://localhost:8080/query", json={"query": query})
+print(f"\nStatus: {r.status_code}")
+print(f"Response: {r.text[:500]}")
+

src/query_planner/analyzer/graph_join/inference.rs

@@ -3561,6 +3561,22 @@ impl GraphJoinInference {
             right_is_referenced
         );
 
+        // Track C: Check if relationship has types (may be filtered to 0 by property-based pruning)
+        // If no types, skip join inference - the Empty plan handles this case
+        if let Ok(rel_ctx) = plan_ctx.get_rel_table_ctx(&graph_rel.alias) {
+            if rel_ctx
+                .get_labels()
+                .map_or(true, |labels| labels.is_empty())
+            {
+                log::info!(
+                    "🔧 GraphJoinInference: Skipping for relationship '{}' with no types (filtered by Track C)",
+                    graph_rel.alias
+                );
+                crate::debug_print!("    +- infer_graph_join EXIT (empty relationship)\n");
+                return Ok(());
+            }
+        }
+
         // Extract all necessary data from graph_context BEFORE passing plan_ctx mutably
         let (
             left_alias_str,

src/query_planner/analyzer/graph_traversal_planning.rs

@@ -362,6 +362,21 @@ impl GraphTRaversalPlanning {
             }
         }
 
+        // Track C: Check if relationship has types (may be filtered to 0 by property-based pruning)
+        // If no types, skip graph traversal planning - the Empty plan handles this case
+        if let Ok(rel_ctx) = plan_ctx.get_rel_table_ctx(&graph_rel.alias) {
+            if rel_ctx
+                .get_labels()
+                .map_or(true, |labels| labels.is_empty())
+            {
+                log::info!(
+                    "🔧 GraphTraversalPlanning: Skipping for relationship '{}' with no types (filtered by Track C)",
+                    graph_rel.alias
+                );
+                return Ok((graph_rel.clone(), vec![]));
+            }
+        }
+
         let graph_context = graph_context::get_graph_context(
             graph_rel,
             plan_ctx,

src/query_planner/analyzer/projection_tagging.rs

@@ -574,7 +574,24 @@ impl ProjectionTagging {
                 }
 
                 // Get label for property resolution
-                let label = table_ctx.get_label_opt().unwrap_or_default();
+                let label = match table_ctx.get_label_opt() {
+                    Some(l) => l,
+                    None => {
+                        // No label - untyped pattern filtered to 0 types by Track C
+                        // Skip property resolution - the query will return 0 rows
+                        log::info!(
+                            "🔧 ProjectionTagging: Skipping property resolution for untyped pattern '{}' with no matching types (filtered to 0 by Track C)",
+                            property_access.table_alias.0
+                        );
+                        // Return property as-is - the Empty plan will handle it
+                        let projection_item = ProjectionItem {
+                            expression: item.expression.clone(),
+                            col_alias: item.col_alias.clone(),
+                        };
+                        table_ctx.insert_projection(projection_item);
+                        return Ok(());
+                    }
+                };
                 let is_relation = table_ctx.is_relation();
 
                 // Resolve property to actual column name using ViewResolver

src/query_planner/logical_plan/mod.rs

@@ -125,6 +125,43 @@ pub fn evaluate_query(
     )
 }
 
+/// Helper function to detect empty or filtered UNION branches
+///
+/// Track C filters branches to 0 types, but creates different "empty" representations:
+/// - Explicit: LogicalPlan::Empty (for nodes filtered to 0 types)
+/// - Implicit: GraphRel{labels: None} (for relationships filtered to 0 types)
+///
+/// This function detects both forms and recursively checks wrapped plans.
+fn is_empty_or_filtered_branch(plan: &LogicalPlan) -> bool {
+    match plan {
+        // Explicit empty
+        LogicalPlan::Empty => true,
+
+        // Implicit empty: relationship filtered to 0 types by Track C
+        LogicalPlan::GraphRel(rel) if rel.labels.is_none() => {
+            log::debug!(
+                "Detected filtered GraphRel (labels=None) for alias '{}'",
+                rel.alias
+            );
+            true
+        }
+
+        // Check if wrapped plan contains Empty
+        LogicalPlan::GraphNode(node) => {
+            matches!(node.input.as_ref(), LogicalPlan::Empty)
+        }
+
+        // Recursively check wrapped plans (common UNION branch structures)
+        LogicalPlan::Projection(proj) => is_empty_or_filtered_branch(&proj.input),
+        LogicalPlan::Filter(f) => is_empty_or_filtered_branch(&f.input),
+        LogicalPlan::GraphJoins(joins) => is_empty_or_filtered_branch(&joins.input),
+        LogicalPlan::Limit(limit) => is_empty_or_filtered_branch(&limit.input),
+
+        // Not empty
+        _ => false,
+    }
+}
+
 /// Evaluate a complete Cypher statement which may contain UNION clauses
 pub fn evaluate_cypher_statement(
     statement: CypherStatement<'_>,
@@ -192,18 +229,47 @@ pub fn evaluate_cypher_statement(
                     view_parameter_values.clone(),
                     max_inferred_types,
                 )?;
-                all_plans.push(plan);
-                // Merge the context from this union branch into combined context
-                if let Some(ref mut combined) = combined_ctx {
-                    combined.merge(ctx);
+
+                // Track C Property Optimization: Skip empty branches
+                // When Track C filters a branch to 0 matching types, detect and skip it
+                // This handles both explicit Empty and implicit GraphRel{labels: None}
+                if !is_empty_or_filtered_branch(plan.as_ref()) {
+                    all_plans.push(plan);
+                    // Merge the context from this union branch into combined context
+                    if let Some(ref mut combined) = combined_ctx {
+                        combined.merge(ctx);
+                    }
+                } else {
+                    log::info!(
+                        "🔀 UNION branch filtered to 0 types by Track C - skipping empty branch"
+                    );
                 }
             }
 
-            // Create Union logical plan
-            let union_plan = Arc::new(LogicalPlan::Union(Union {
-                inputs: all_plans,
-                union_type,
-            }));
+            // Handle different scenarios based on non-empty branch count
+            let union_plan = match all_plans.len() {
+                0 => {
+                    // All branches filtered to 0 types - return empty result
+                    log::info!("🔀 All UNION branches empty - returning Empty plan (0 rows)");
+                    Arc::new(LogicalPlan::Empty)
+                }
+                1 => {
+                    // Only one branch has data - no UNION needed
+                    log::info!("🔀 Only 1 non-empty UNION branch - skipping UNION wrapper");
+                    all_plans.into_iter().next().unwrap()
+                }
+                _ => {
+                    // Multiple branches with data - create UNION
+                    log::info!(
+                        "🔀 Creating UNION with {} non-empty branches",
+                        all_plans.len()
+                    );
+                    Arc::new(LogicalPlan::Union(Union {
+                        inputs: all_plans,
+                        union_type,
+                    }))
+                }
+            };
 
             let final_ctx = combined_ctx.ok_or_else(|| {
                 LogicalPlanError::QueryPlanningError(