Merge branch 'main' into fix/track-c-empty-branch-handling

Author: genezhang

benchmarks/social_network/schemas/social_benchmark.yaml

@@ -62,7 +62,7 @@ graph_schema:
     - type: AUTHORED
       database: brahmand
       table: posts_bench
-      from_id: author_id
+      from_id: user_id  # FIXED: Actual column is user_id, not author_id
       to_id: post_id
       edge_id: post_id
       from_node: User
@@ -78,7 +78,7 @@ graph_schema:
       from_node: User
       to_node: Post
       property_mappings:
-        like_date: like_date
+        like_date: liked_at  # FIXED: Actual column is liked_at, not like_date
 
     - type: FRIENDS_WITH
       database: brahmand

src/clickhouse_query_generator/to_sql.rs

@@ -295,17 +295,17 @@ impl ToSql for LogicalExpr {
                 ))
             }
             LogicalExpr::MapLiteral(entries) => {
-                // Map literals are handled specially by function translator
-                // If we reach here directly, just format as key-value pairs for debugging
-                // In practice, duration({days: 5}) is handled by translate_scalar_function
-                let pairs: Result<Vec<String>, _> = entries
-                    .iter()
-                    .map(|(k, v)| {
-                        let val_sql = v.to_sql()?;
-                        Ok(format!("'{}': {}", k, val_sql))
-                    })
-                    .collect();
-                Ok(format!("{{{}}}", pairs?.join(", ")))
+                // Use ClickHouse map() function for map literals
+                // map('key1', val1, 'key2', val2, ...)
+                if entries.is_empty() {
+                    Ok("map()".to_string())
+                } else {
+                    let args: Result<Vec<String>, _> = entries
+                        .iter()
+                        .flat_map(|(k, v)| vec![Ok(format!("'{}'", k)), v.to_sql()])
+                        .collect();
+                    Ok(format!("map({})", args?.join(", ")))
+                }
             }
             LogicalExpr::LabelExpression { variable, label } => {
                 // Label expression should typically be resolved at planning time

src/clickhouse_query_generator/to_sql_query.rs

@@ -2365,17 +2365,20 @@ impl RenderExpr {
                 )
             }
             RenderExpr::MapLiteral(entries) => {
-                // Map literals are handled specially by function translator
-                // If we reach here directly, just format as key-value pairs for debugging
-                // In practice, duration({days: 5}) is handled by translate_scalar_function
-                let pairs: Vec<String> = entries
-                    .iter()
-                    .map(|(k, v)| {
-                        let val_sql = v.to_sql();
-                        format!("'{}': {}", k, val_sql)
-                    })
-                    .collect();
-                format!("{{{}}}", pairs.join(", "))
+                // Use ClickHouse map() function for map literals
+                // map('key1', val1, 'key2', val2, ...)
+                if entries.is_empty() {
+                    "map()".to_string()
+                } else {
+                    let args: Vec<String> = entries
+                        .iter()
+                        .flat_map(|(k, v)| {
+                            let val_sql = v.to_sql();
+                            vec![format!("'{}'", k), val_sql]
+                        })
+                        .collect();
+                    format!("map({})", args.join(", "))
+                }
             }
             RenderExpr::PatternCount(pc) => {
                 // Use the pre-generated SQL from PatternCount (correlated subquery)

src/query_planner/analyzer/filter_tagging.rs

@@ -686,21 +686,65 @@ impl FilterTagging {
                 }
 
                 // Get the label for this table
+                // First try plan_ctx (works for typed patterns)
+                // If None, try to find it in the plan tree (works for UNION branches where
+                // each branch has a typed GraphNode but the global plan_ctx still has untyped entry)
                 let label = match table_ctx.get_label_opt() {
-                    Some(l) => l,
-                    None => {
-                        // No label yet - this is an untyped pattern like MATCH (n)
-                        // Property validation will happen during scan generation when we filter types
-                        // For now, pass through the property access as-is
-                        log::info!(
-                            "🔧 FilterTagging: Skipping validation for untyped pattern '{}', property='{}' (will validate during scan generation)",
-                            property_access.table_alias.0,
-                            property_access.column.raw()
-                        );
-                        return Ok(LogicalExpr::PropertyAccessExp(property_access));
+                    Some(l) if !l.is_empty() => l, // Skip empty labels (from pruned branches)
+                    _ => {
+                        // Try to get label from the plan tree (for UNION branches)
+                        if let Some(plan_ref) = plan {
+                            if let Some(label_from_plan) =
+                                Self::find_label_in_plan(plan_ref, &property_access.table_alias.0)
+                            {
+                                if label_from_plan.is_empty() {
+                                    // Empty label means this branch was pruned (no matching types)
+                                    // Skip property mapping - the branch will return 0 rows anyway
+                                    log::info!(
+                                        "🔧 FilterTagging: Skipping property mapping for pruned branch '{}', property='{}'",
+                                        property_access.table_alias.0,
+                                        property_access.column.raw()
+                                    );
+                                    return Ok(LogicalExpr::PropertyAccessExp(property_access));
+                                }
+                                log::info!(
+                                    "🔧 FilterTagging: Found label '{}' from plan tree for untyped pattern '{}', property='{}'",
+                                    label_from_plan,
+                                    property_access.table_alias.0,
+                                    property_access.column.raw()
+                                );
+                                label_from_plan
+                            } else {
+                                // No label in plan either - truly untyped, pass through as-is
+                                log::info!(
+                                    "🔧 FilterTagging: Skipping validation for untyped pattern '{}', property='{}' (will validate during scan generation)",
+                                    property_access.table_alias.0,
+                                    property_access.column.raw()
+                                );
+                                return Ok(LogicalExpr::PropertyAccessExp(property_access));
+                            }
+                        } else {
+                            // No plan reference - pass through as-is
+                            log::info!(
+                                "🔧 FilterTagging: Skipping validation for untyped pattern '{}', property='{}' (no plan context)",
+                                property_access.table_alias.0,
+                                property_access.column.raw()
+                            );
+                            return Ok(LogicalExpr::PropertyAccessExp(property_access));
+                        }
                     }
                 };
 
+                // Handle empty label case (branch was pruned by property-based filtering)
+                if label.is_empty() {
+                    log::info!(
+                        "🔧 FilterTagging: Skipping property mapping for pruned branch '{}' (empty label), property='{}'",
+                        property_access.table_alias.0,
+                        property_access.column.raw()
+                    );
+                    return Ok(LogicalExpr::PropertyAccessExp(property_access));
+                }
+
                 // Check if this node uses EmbeddedInEdge strategy (denormalized access)
                 let (is_embedded_in_edge, _owning_edge_info) = if let Some(plan) = plan {
                     // Also check by traversing the plan to find which edge owns this node
@@ -1680,6 +1724,44 @@ impl FilterTagging {
         }
     }
 
+    /// Find the label for an alias by looking at GraphNode in the plan tree
+    /// This is used for UNION branches where the branch has a typed GraphNode
+    /// but the global plan_ctx still has the untyped entry
+    fn find_label_in_plan(plan: &LogicalPlan, alias: &str) -> Option<String> {
+        match plan {
+            LogicalPlan::GraphNode(node) => {
+                if node.alias == alias {
+                    return node.label.clone();
+                }
+                Self::find_label_in_plan(&node.input, alias)
+            }
+            LogicalPlan::Filter(filter) => Self::find_label_in_plan(&filter.input, alias),
+            LogicalPlan::Projection(proj) => Self::find_label_in_plan(&proj.input, alias),
+            LogicalPlan::GraphJoins(joins) => Self::find_label_in_plan(&joins.input, alias),
+            LogicalPlan::GroupBy(gb) => Self::find_label_in_plan(&gb.input, alias),
+            LogicalPlan::OrderBy(ob) => Self::find_label_in_plan(&ob.input, alias),
+            LogicalPlan::Skip(skip) => Self::find_label_in_plan(&skip.input, alias),
+            LogicalPlan::Limit(limit) => Self::find_label_in_plan(&limit.input, alias),
+            LogicalPlan::Cte(cte) => Self::find_label_in_plan(&cte.input, alias),
+            LogicalPlan::GraphRel(rel) => {
+                if let Some(l) = Self::find_label_in_plan(&rel.left, alias) {
+                    return Some(l);
+                }
+                if let Some(l) = Self::find_label_in_plan(&rel.center, alias) {
+                    return Some(l);
+                }
+                Self::find_label_in_plan(&rel.right, alias)
+            }
+            LogicalPlan::CartesianProduct(cp) => {
+                if let Some(l) = Self::find_label_in_plan(&cp.left, alias) {
+                    return Some(l);
+                }
+                Self::find_label_in_plan(&cp.right, alias)
+            }
+            _ => None,
+        }
+    }
+
     /// Check if a plan has a CartesianProduct descendant
     /// Used to identify cross-table join conditions that should not be extracted
     fn has_cartesian_product_descendant(plan: &LogicalPlan) -> bool {

src/query_planner/analyzer/graph_join/cross_branch.rs

@@ -98,6 +98,11 @@ pub fn generate_relationship_uniqueness_constraints(
                 continue;
             }
 
+            // Skip if either edge has no relationship types (filtered by property filtering)
+            if edge1.rel_types.is_empty() || edge2.rel_types.is_empty() {
+                continue;
+            }
+
             // Get relationship schemas to determine edge ID columns
             let rel1_schema = match graph_schema.get_rel_schema(&edge1.rel_types[0]) {
                 Ok(schema) => schema,
@@ -244,6 +249,16 @@ pub fn generate_cross_branch_joins_from_metadata(
         let mut to_edges: HashMap<String, Vec<&super::metadata::PatternEdgeInfo>> = HashMap::new();
 
         for edge in &edges {
+            // Skip edges with no relationship types (filtered out by property filtering)
+            if edge.rel_types.is_empty() {
+                log::debug!(
+                    "🔍 Skipping edge {}->{}->{}  with no relationship types (filtered)",
+                    edge.from_node,
+                    edge.alias,
+                    edge.to_node
+                );
+                continue;
+            }
             let rel_schema = graph_schema
                 .get_rel_schema(&edge.rel_types[0])
                 .map_err(|e| AnalyzerError::GraphSchema {
@@ -336,6 +351,20 @@ fn create_cross_branch_join_from_edges(
         if is_from_side { "from_node" } else { "to_node" }
     );
 
+    // Guard: Skip if either edge has no relationship types (filtered by property filtering)
+    if edge1.rel_types.is_empty() {
+        return Err(AnalyzerError::SchemaNotFound(format!(
+            "Edge '{}' has no relationship types (filtered by property filtering)",
+            edge1.alias
+        )));
+    }
+    if edge2.rel_types.is_empty() {
+        return Err(AnalyzerError::SchemaNotFound(format!(
+            "Edge '{}' has no relationship types (filtered by property filtering)",
+            edge2.alias
+        )));
+    }
+
     // Get relationship schemas
     let rel1_schema = graph_schema
         .get_rel_schema(&edge1.rel_types[0])

src/query_planner/analyzer/view_resolver.rs

@@ -153,6 +153,20 @@ impl<'a> ViewResolver<'a> {
         from_node: Option<&str>,
         to_node: Option<&str>,
     ) -> Result<crate::graph_catalog::expression_parser::PropertyValue, AnalyzerError> {
+        // Handle empty type_name (from pruned/empty branches)
+        // Return property as-is - the branch will return 0 rows anyway
+        if type_name.is_empty() {
+            log::info!(
+                "ViewResolver: Empty relationship type - returning property '{}' as-is (branch was pruned)",
+                property
+            );
+            return Ok(
+                crate::graph_catalog::expression_parser::PropertyValue::Column(
+                    property.to_string(),
+                ),
+            );
+        }
+
         log::debug!(
             "ViewResolver: Resolving rel property: type_name={}, property={}, from_node={:?}, to_node={:?}",
             type_name, property, from_node, to_node

src/query_planner/logical_plan/match_clause/helpers.rs

@@ -133,16 +133,19 @@ pub fn generate_scan(
             }
         } else {
             // Multiple node types - create UNION ALL of ViewScans
-            log::info!(
-                "Creating UNION of {} node types for labelless query: {:?}",
+            log::warn!(
+                "🔍 Creating UNION of {} node types for labelless query: {:?}",
                 labels_to_use.len(),
                 labels_to_use
             );
 
             let mut union_inputs = Vec::new();
             for label in &labels_to_use {
                 match super::try_generate_view_scan(&alias, label, plan_ctx)? {
-                    Some(view_scan) => union_inputs.push(view_scan),
+                    Some(view_scan) => {
+                        log::warn!("🔍 Added ViewScan for label '{}': {:?}", label, view_scan);
+                        union_inputs.push(view_scan);
+                    }
                     None => {
                         log::warn!("Skipping label '{}' - not found in schema", label);
                     }
@@ -396,11 +399,18 @@ pub fn register_node_in_context(
     node_props: Vec<Property>,
     is_explicitly_named: bool,
 ) {
+    // Use Some(vec![]) for unlabeled nodes instead of None
+    // This distinguishes unlabeled nodes from path variables (which use None)
+    let labels_for_ctx = match node_label {
+        Some(l) => Some(vec![l.clone()]),
+        None => Some(vec![]), // Explicitly empty = unlabeled node (not a path)
+    };
+
     plan_ctx.insert_table_ctx(
         node_alias.to_string(),
         TableCtx::build(
             node_alias.to_string(),
-            node_label.clone().map(|l| vec![l]),
+            labels_for_ctx,
             node_props,
             false, // is_rel
             is_explicitly_named,

src/query_planner/logical_plan/match_clause/traversal.rs

@@ -298,6 +298,27 @@ fn traverse_connected_pattern_with_mode<'a>(
             }
         };
 
+        // === HANDLE NO MATCHING RELATIONSHIP TYPES ===
+        // If property filtering removed all relationship types, return Empty plan
+        if rel_labels.is_none() {
+            log::warn!(
+                "🔀 No relationship types found for alias '{}' after property filtering - returning Empty",
+                rel_alias
+            );
+            // Register the relationship alias with empty labels to prevent downstream errors
+            plan_ctx.insert_table_ctx(
+                rel_alias.clone(),
+                crate::query_planner::plan_ctx::TableCtx::build(
+                    rel_alias.clone(),
+                    Some(vec![]), // Empty labels
+                    vec![],
+                    true,
+                    false,
+                ),
+            );
+            return Ok(Arc::new(LogicalPlan::Empty));
+        }
+
         // === FULLY UNTYPED MULTI-TYPE UNION EXPANSION ===
         // For patterns like ()-->() where BOTH nodes are untyped AND we have multiple relationship types,
         // generate a UNION where each branch processes as a typed pattern through the normal flow.
@@ -1356,10 +1377,42 @@ pub(super) fn traverse_node_pattern(
                 .iter()
                 .map(|branch| {
                     let is_denorm = is_denormalized_scan(branch);
+                    // For UNION branches from untyped patterns (MATCH (n)), extract the label
+                    // from the ViewScan source_table to enable property mapping in FilterTagging.
+                    // The ViewScan was created by generate_scan with a specific node type.
+                    let branch_label = if node_label.is_none() {
+                        // Extract label from ViewScan's source_table
+                        // The source_table format is "database.table_name" e.g. "brahmand.users_bench"
+                        if let LogicalPlan::ViewScan(vs) = branch.as_ref() {
+                            // Try to find the node label by looking up which node type uses this table
+                            let table_name = vs.source_table.split('.').last().unwrap_or(&vs.source_table);
+                            plan_ctx.schema().all_node_schemas()
+                                .iter()
+                                .find_map(|(label, schema)| {
+                                    // Check if this schema's table matches
+                                    let schema_table = schema.table_name.split('.').last().unwrap_or(&schema.table_name);
+                                    if schema_table == table_name {
+                                        Some(label.clone())
+                                    } else {
+                                        None
+                                    }
+                                })
+                        } else {
+                            None
+                        }
+                    } else {
+                        node_label.clone().map(|s| s.to_string())
+                    };
+
+                    log::info!(
+                        "  ✓ Wrapping branch with alias='{}', label={:?} (original node_label={:?})",
+                        node_alias, branch_label, node_label
+                    );
+
                     Arc::new(LogicalPlan::GraphNode(GraphNode {
                         input: branch.clone(),
                         alias: node_alias.clone(),
-                        label: node_label.clone().map(|s| s.to_string()),
+                        label: branch_label,
                         is_denormalized: is_denorm,
                         projected_columns: None,
                     }))