style: fix trailing whitespace

- Removed trailing whitespace from plan_builder_utils.rs
- All code formatting now clean per cargo fmt
- No clippy warnings in modified files

Author: genezhang

src/clickhouse_query_generator/to_sql_query.rs

@@ -23,7 +23,7 @@ use super::function_translator::{get_ch_function_name, CH_PASSTHROUGH_PREFIX};
 /// TASK-LOCAL RENDER CONTEXT: Per-async-task storage for query rendering
 /// Each Axum async task (HTTP request) gets its own isolated context.
 /// Multiple concurrent queries on same OS thread have zero interference.
-/// 
+///
 /// Why task_local instead of thread_local:
 /// - thread_local: Shared by all async tasks on same OS thread (UNSAFE for concurrent queries)
 /// - task_local: Each async task gets isolated storage (SAFE)
@@ -46,9 +46,9 @@ fn get_cte_column_from_context(cte_alias: &str, property: &str) -> Option<String
     // task_local! uses sync accessors, not .with()
     RENDER_CONTEXT_CTE_REGISTRY
         .try_with(|ctx| {
-            ctx.borrow().as_ref().and_then(|registry| {
-                registry.lookup(cte_alias, property)
-            })
+            ctx.borrow()
+                .as_ref()
+                .and_then(|registry| registry.lookup(cte_alias, property))
         })
         .ok()
         .flatten()
@@ -80,9 +80,7 @@ fn clear_render_context_cte_registry() {
 // RELATIONSHIP COLUMNS CONTEXT (for IS NULL checks on relationship aliases)
 // ============================================================================
 
-fn set_render_context_relationship_columns(
-    columns: HashMap<String, (String, String)>,
-) {
+fn set_render_context_relationship_columns(columns: HashMap<String, (String, String)>) {
     let _ = RENDER_CONTEXT_RELATIONSHIP_COLUMNS.try_with(|ctx| {
         ctx.borrow_mut().replace(columns);
     });
@@ -109,9 +107,7 @@ fn clear_render_context_relationship_columns() {
 // CTE PROPERTY MAPPINGS CONTEXT (for CTE property → column resolution)
 // ============================================================================
 
-fn set_render_context_cte_property_mappings(
-    mappings: HashMap<String, HashMap<String, String>>,
-) {
+fn set_render_context_cte_property_mappings(mappings: HashMap<String, HashMap<String, String>>) {
     let _ = RENDER_CONTEXT_CTE_PROPERTY_MAPPINGS.try_with(|ctx| {
         ctx.borrow_mut().replace(mappings);
     });
@@ -189,7 +185,7 @@ fn clear_all_render_contexts() {
 /// TASK-LOCAL RENDER CONTEXT: Per-async-task storage for rendering state
 /// Each Axum async task (HTTP request) gets its own isolated context.
 /// Multiple concurrent queries on same OS thread have zero interference.
-/// 
+///
 /// Lifecycle:
 /// 1. At render_to_sql() entry: Set all three contexts
 /// 2. During rendering: Access contexts for property/column lookups
@@ -373,7 +369,7 @@ fn build_multi_type_vlp_aliases(plan: &RenderPlan) -> HashMap<String, String> {
 fn populate_cte_property_mappings(plan: &RenderPlan) {
     let cte_mappings = build_cte_property_mappings(plan);
     let multi_type_aliases = build_multi_type_vlp_aliases(plan);
-    
+
     set_render_context_cte_property_mappings(cte_mappings);
     set_render_context_multi_type_vlp_aliases(multi_type_aliases);
 }
@@ -622,7 +618,9 @@ fn derive_cypher_property_name(db_column: &str) -> String {
 
 /// Extract fixed path information from a RenderPlan by analyzing SELECT items and JOINs
 /// Returns FixedPathMetadata if the plan contains a path function call that can be resolved
-fn extract_fixed_path_info_from_plan(plan: &RenderPlan) -> Option<crate::render_plan::FixedPathMetadata> {
+fn extract_fixed_path_info_from_plan(
+    plan: &RenderPlan,
+) -> Option<crate::render_plan::FixedPathMetadata> {
     // Look for path function calls in SELECT items
     for item in &plan.select.items {
         if let Some(path_var) = find_path_function_argument(&item.expression) {
@@ -632,14 +630,14 @@ fn extract_fixed_path_info_from_plan(plan: &RenderPlan) -> Option<crate::render_
             // For a path (a)-[:T1]->(b)-[:T2]->(c), we have 4 JOINs = 2 hops
             // Formula: hops = JOINs / 2 (integer division)
             let hop_count = plan.joins.0.len() as u32 / 2;
-            
+
             log::info!(
                 "🔧 Detected fixed path: path_variable={}, hop_count={} (from {} JOINs)",
                 path_var,
                 hop_count,
                 plan.joins.0.len()
             );
-            
+
             return Some(crate::render_plan::FixedPathMetadata {
                 path_variable: path_var,
                 hop_count,
@@ -648,7 +646,7 @@ fn extract_fixed_path_info_from_plan(plan: &RenderPlan) -> Option<crate::render_
             });
         }
     }
-    
+
     // Also check GROUP BY and ORDER BY expressions
     for expr in &plan.group_by.0 {
         if let Some(path_var) = find_path_function_argument(expr) {
@@ -661,7 +659,7 @@ fn extract_fixed_path_info_from_plan(plan: &RenderPlan) -> Option<crate::render_
             });
         }
     }
-    
+
     for item in &plan.order_by.0 {
         if let Some(path_var) = find_path_function_argument(&item.expression) {
             let hop_count = plan.joins.0.len() as u32 / 2;
@@ -673,7 +671,7 @@ fn extract_fixed_path_info_from_plan(plan: &RenderPlan) -> Option<crate::render_
             });
         }
     }
-    
+
     None
 }
 
@@ -683,14 +681,17 @@ fn find_path_function_argument(expr: &RenderExpr) -> Option<String> {
     match expr {
         RenderExpr::ScalarFnCall(func) => {
             // Check for path functions
-            if matches!(func.name.to_lowercase().as_str(), "length" | "nodes" | "relationships") {
+            if matches!(
+                func.name.to_lowercase().as_str(),
+                "length" | "nodes" | "relationships"
+            ) {
                 if func.args.len() == 1 {
                     if let RenderExpr::TableAlias(alias) = &func.args[0] {
                         return Some(alias.0.clone());
                     }
                 }
             }
-            
+
             // Recursively check arguments
             for arg in &func.args {
                 if let Some(var) = find_path_function_argument(arg) {
@@ -699,7 +700,7 @@ fn find_path_function_argument(expr: &RenderExpr) -> Option<String> {
             }
             None
         }
-        
+
         RenderExpr::OperatorApplicationExp(op) => {
             for operand in &op.operands {
                 if let Some(var) = find_path_function_argument(operand) {
@@ -708,7 +709,7 @@ fn find_path_function_argument(expr: &RenderExpr) -> Option<String> {
             }
             None
         }
-        
+
         RenderExpr::AggregateFnCall(agg) => {
             for arg in &agg.args {
                 if let Some(var) = find_path_function_argument(arg) {
@@ -717,7 +718,7 @@ fn find_path_function_argument(expr: &RenderExpr) -> Option<String> {
             }
             None
         }
-        
+
         _ => None,
     }
 }
@@ -750,15 +751,22 @@ fn rewrite_fixed_path_functions(mut plan: RenderPlan) -> RenderPlan {
         }
 
         // Also rewrite GROUP BY expressions
-        log::info!("🔧 Fixed path GROUP BY rewriting: {} items", plan.group_by.0.len());
+        log::info!(
+            "🔧 Fixed path GROUP BY rewriting: {} items",
+            plan.group_by.0.len()
+        );
         for group_expr in &mut plan.group_by.0 {
             *group_expr = rewrite_expr_for_fixed_path(group_expr, &path_var, hop_count);
         }
 
         // Also rewrite ORDER BY expressions
-        log::info!("🔧 Fixed path ORDER BY rewriting: {} items", plan.order_by.0.len());
+        log::info!(
+            "🔧 Fixed path ORDER BY rewriting: {} items",
+            plan.order_by.0.len()
+        );
         for order_item in &mut plan.order_by.0 {
-            order_item.expression = rewrite_expr_for_fixed_path(&order_item.expression, &path_var, hop_count);
+            order_item.expression =
+                rewrite_expr_for_fixed_path(&order_item.expression, &path_var, hop_count);
         }
     }
 
@@ -1167,31 +1175,30 @@ impl SelectItems {
             // 🔧 SCALAR FIX: ColumnAlias never gets `.*` expansion - it's a scalar column reference
             // This handles: WITH n.email as group_key ... RETURN group_key
             // where group_key is a scalar column, not a node/table
-            let rendered_expr =
-                if let RenderExpr::ColumnAlias(_) = &item.expression {
-                    // ColumnAlias is always rendered as-is (scalar reference)
-                    // No wildcard expansion: group_key stays group_key, not group_key.*
-                    item.expression.to_sql()
-                } else if let RenderExpr::TableAlias(TableAlias(alias_name)) = &item.expression {
-                    if let Some(col_alias) = &item.col_alias {
-                        if alias_name == &col_alias.0 {
-                            // Check if this is an UNWIND alias - don't use `.*` for scalars
-                            if unwind_aliases.contains(alias_name) {
-                                // UNWIND alias: render as just the alias (scalar value)
-                                alias_name.clone()
-                            } else {
-                                // Path/table alias: use `.*` expansion
-                                format!("{}.*", alias_name)
-                            }
+            let rendered_expr = if let RenderExpr::ColumnAlias(_) = &item.expression {
+                // ColumnAlias is always rendered as-is (scalar reference)
+                // No wildcard expansion: group_key stays group_key, not group_key.*
+                item.expression.to_sql()
+            } else if let RenderExpr::TableAlias(TableAlias(alias_name)) = &item.expression {
+                if let Some(col_alias) = &item.col_alias {
+                    if alias_name == &col_alias.0 {
+                        // Check if this is an UNWIND alias - don't use `.*` for scalars
+                        if unwind_aliases.contains(alias_name) {
+                            // UNWIND alias: render as just the alias (scalar value)
+                            alias_name.clone()
                         } else {
-                            item.expression.to_sql()
+                            // Path/table alias: use `.*` expansion
+                            format!("{}.*", alias_name)
                         }
                     } else {
                         item.expression.to_sql()
                     }
                 } else {
                     item.expression.to_sql()
-                };
+                }
+            } else {
+                item.expression.to_sql()
+            };
 
             sql.push_str(&rendered_expr);
 
@@ -2055,10 +2062,18 @@ impl RenderExpr {
                 if is_multi_type_vlp_alias_from_context(&table_alias.0) {
                     log::info!("🎯 Found '{}' in multi-type VLP aliases!", table_alias.0);
                     // Properties like end_type, end_id, hop_count, path_relationships are direct CTE columns
-                    if col_name == VLP_START_ID_COLUMN || col_name == VLP_END_ID_COLUMN
-                        || matches!(col_name, "end_type" | "end_properties" | "hop_count" | "path_relationships")
+                    if col_name == VLP_START_ID_COLUMN
+                        || col_name == VLP_END_ID_COLUMN
+                        || matches!(
+                            col_name,
+                            "end_type" | "end_properties" | "hop_count" | "path_relationships"
+                        )
                     {
-                        log::info!("🎯 Multi-type VLP CTE column: {}.{}", table_alias.0, col_name);
+                        log::info!(
+                            "🎯 Multi-type VLP CTE column: {}.{}",
+                            table_alias.0,
+                            col_name
+                        );
                         return format!("{}.{}", table_alias.0, col_name);
                     } else {
                         // Regular properties need JSON extraction from end_properties
@@ -2157,7 +2172,9 @@ impl RenderExpr {
 
                             // Look up the actual column name from the JOIN metadata (populated during rendering)
                             // This ensures we use the CORRECT column for the SPECIFIC relationship table
-                            if let Some((from_id, _to_id)) = get_relationship_columns_from_context(table_alias) {
+                            if let Some((from_id, _to_id)) =
+                                get_relationship_columns_from_context(table_alias)
+                            {
                                 // Use from_id - any ID column works since LEFT JOIN makes all NULL together
                                 let id_sql = format!("{}.{}", table_alias, from_id);
                                 return format!("{} {}", id_sql, op_str);

src/query_planner/analyzer/schema_inference.rs

@@ -54,7 +54,11 @@ impl SchemaInference {
                     // Get inferred label from TableCtx
                     match plan_ctx.get_table_ctx(&graph_node.alias) {
                         Ok(table_ctx) => {
-                            log::debug!("SchemaInference: Found table_ctx for node '{}' with labels {:?}", graph_node.alias, table_ctx.get_labels());
+                            log::debug!(
+                                "SchemaInference: Found table_ctx for node '{}' with labels {:?}",
+                                graph_node.alias,
+                                table_ctx.get_labels()
+                            );
                             if let Some(labels) = table_ctx.get_labels() {
                                 if !labels.is_empty() && labels[0] != "$any" {
                                     let label = &labels[0];
@@ -99,11 +103,18 @@ impl SchemaInference {
                                     log::debug!("SchemaInference: Node '{}' has no labels or $any label, skipping ViewScan creation", graph_node.alias);
                                 }
                             } else {
-                                log::debug!("SchemaInference: No labels found for node '{}' in table_ctx", graph_node.alias);
+                                log::debug!(
+                                    "SchemaInference: No labels found for node '{}' in table_ctx",
+                                    graph_node.alias
+                                );
                             }
                         }
                         Err(e) => {
-                            log::debug!("SchemaInference: No table_ctx found for node '{}': {:?}", graph_node.alias, e);
+                            log::debug!(
+                                "SchemaInference: No table_ctx found for node '{}': {:?}",
+                                graph_node.alias,
+                                e
+                            );
                         }
                     }
                 }

src/query_planner/analyzer/variable_resolver.rs

@@ -177,7 +177,7 @@ impl ScopeContext {
 pub struct VariableResolver {
     /// Counter for generating unique CTE names
     cte_counter: std::cell::RefCell<usize>,
-    
+
     /// Collected alias sources during analysis: exported_alias → (source_alias, cte_name)
     /// These are registered into PlanCtx after resolution completes
     alias_sources: std::cell::RefCell<HashMap<String, (String, String)>>,
@@ -355,14 +355,16 @@ impl VariableResolver {
                 for (i, item) in resolved_items.iter().enumerate() {
                     if i < wc.exported_aliases.len() {
                         let exported_alias = &wc.exported_aliases[i];
-                        
+
                         // Try to extract the source alias from the expression
                         // Common case: WITH u AS person - expression is TableAlias("u")
                         if let LogicalExpr::TableAlias(source_alias_ta) = &item.expression {
                             let source_alias_str = source_alias_ta.0.clone();
                             log::info!(
                                 "🔍 VariableResolver: Collecting alias source: {} ← ({}, {})",
-                                exported_alias, source_alias_str, cte_name
+                                exported_alias,
+                                source_alias_str,
+                                cte_name
                             );
                             self.alias_sources.borrow_mut().insert(
                                 exported_alias.clone(),
@@ -1224,7 +1226,9 @@ impl AnalyzerPass for VariableResolver {
         for (exported_alias, (source_alias, cte_name)) in alias_sources.iter() {
             log::info!(
                 "🔍 VariableResolver: Registering alias source {} ← ({}, {})",
-                exported_alias, source_alias, cte_name
+                exported_alias,
+                source_alias,
+                cte_name
             );
             plan_ctx.register_cte_alias_source(
                 exported_alias.clone(),

src/render_plan/cte_manager/mod.rs

@@ -48,7 +48,7 @@ pub enum CteError {
 }
 
 /// Metadata for a column in a generated CTE
-/// 
+///
 /// This provides complete information for mapping Cypher property accesses to CTE columns
 /// WITHOUT heuristics or underscore splitting.
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]

src/render_plan/join_builder.rs

@@ -1873,7 +1873,7 @@ impl JoinBuilder for LogicalPlan {
                     "🔧 DEBUG: About to push JOIN 2 (end node): {} AS {}",
                     end_table, graph_rel.right_connection
                 );
-                
+
                 // DENORMALIZED EDGE CHECK: Only add JOIN 2 if target node is a different table
                 // For denormalized edges (e.g., AUTHORED with posts_bench as both edge+node),
                 // end_table == rel_table, so we should NOT join the table again
@@ -1896,7 +1896,8 @@ impl JoinBuilder for LogicalPlan {
                     );
                     log::info!(
                         "✓ Denormalized edge for {}: table '{}' serves as both edge and node",
-                        graph_rel.alias, rel_table
+                        graph_rel.alias,
+                        rel_table
                     );
                 }
 

src/render_plan/mod.rs

@@ -85,7 +85,7 @@ pub struct RenderPlan {
     pub fixed_path_info: Option<FixedPathMetadata>,
     /// Per-query CTE column registry - maps (alias, property) to CTE output column name
     /// Used during SQL rendering to resolve property accesses from WITH clauses
-    #[serde(skip)]  // Don't serialize, recreate during rendering
+    #[serde(skip)] // Don't serialize, recreate during rendering
     pub cte_column_registry: CteColumnRegistry,
 }