code fmt

Author: genezhang

src/query_planner/logical_expr/ast_conversion.rs

@@ -204,16 +204,12 @@ impl<'a> TryFrom<open_cypher_parser::ast::PathPattern<'a>> for PathPattern {
                     .collect::<Result<Vec<_>, _>>()?;
                 Ok(PathPattern::ConnectedPattern(connected_patterns))
             }
-            open_cypher_parser::ast::PathPattern::ShortestPath(inner) => {
-                Ok(PathPattern::ShortestPath(Box::new(PathPattern::try_from(
-                    *inner,
-                )?)))
-            }
-            open_cypher_parser::ast::PathPattern::AllShortestPaths(inner) => {
-                Ok(PathPattern::AllShortestPaths(Box::new(
-                    PathPattern::try_from(*inner)?,
-                )))
-            }
+            open_cypher_parser::ast::PathPattern::ShortestPath(inner) => Ok(
+                PathPattern::ShortestPath(Box::new(PathPattern::try_from(*inner)?)),
+            ),
+            open_cypher_parser::ast::PathPattern::AllShortestPaths(inner) => Ok(
+                PathPattern::AllShortestPaths(Box::new(PathPattern::try_from(*inner)?)),
+            ),
         }
     }
 }
@@ -477,11 +473,9 @@ impl<'a> std::convert::TryFrom<open_cypher_parser::ast::Expression<'a>> for Logi
             )),
             Expression::PathPattern(pp) => Ok(LogicalExpr::PathPattern(PathPattern::try_from(pp)?)),
             Expression::Case(case) => Ok(LogicalExpr::Case(LogicalCase::try_from(case)?)),
-            Expression::ExistsExpression(exists) => {
-                Ok(LogicalExpr::ExistsSubquery(ExistsSubquery::try_from(
-                    *exists,
-                )?))
-            }
+            Expression::ExistsExpression(exists) => Ok(LogicalExpr::ExistsSubquery(
+                ExistsSubquery::try_from(*exists)?,
+            )),
             Expression::ReduceExp(reduce) => Ok(LogicalExpr::ReduceExpr(ReduceExpr {
                 accumulator: reduce.accumulator.to_string(),
                 initial_value: Box::new(Self::try_from(*reduce.initial_value)?),

src/query_planner/logical_expr/combinators.rs

@@ -73,13 +73,11 @@ pub fn is_comparison(expr: &LogicalExpr) -> bool {
 /// `(a AND (b AND c))` → `[a, b, c]`
 pub fn flatten_boolean_op(expr: &LogicalExpr, op: Operator) -> Vec<LogicalExpr> {
     match expr {
-        LogicalExpr::OperatorApplicationExp(op_app) if op_app.operator == op => {
-            op_app
-                .operands
-                .iter()
-                .flat_map(|operand| flatten_boolean_op(operand, op))
-                .collect()
-        }
+        LogicalExpr::OperatorApplicationExp(op_app) if op_app.operator == op => op_app
+            .operands
+            .iter()
+            .flat_map(|operand| flatten_boolean_op(operand, op))
+            .collect(),
         other => vec![other.clone()],
     }
 }

src/query_planner/logical_expr/mod.rs

@@ -30,7 +30,6 @@ pub mod errors;
 pub mod expression_rewriter;
 pub mod visitors;
 
-
 /// Type of graph entity (node or relationship).
 /// Used in CteEntityRef to indicate what kind of entity is being referenced.
 #[derive(Debug, PartialEq, Clone, Copy, Serialize, Deserialize)]
@@ -438,7 +437,6 @@ pub struct RelationshipPattern {
     pub properties: Option<Vec<Property>>,
 }
 
-
 // =============================================================================
 // Display Implementations
 // =============================================================================
@@ -920,7 +918,7 @@ impl LogicalExpr {
 #[test]
 fn test_pattern_comprehension_error_instead_of_panic() {
     use crate::open_cypher_parser;
-    
+
     // Test that PatternComprehension now returns an error instead of panicking
     let pattern_comprehension = open_cypher_parser::ast::Expression::PatternComprehension(
         open_cypher_parser::ast::PatternComprehension {

src/query_planner/logical_expr/visitors.rs

@@ -251,7 +251,9 @@ impl ExpressionVisitor for PropertyAccessCollector {
     fn visit_property_access(&mut self, prop: &PropertyAccess) {
         let property_name = match &prop.column {
             crate::graph_catalog::expression_parser::PropertyValue::Column(col) => col.clone(),
-            crate::graph_catalog::expression_parser::PropertyValue::Expression(expr) => expr.clone(),
+            crate::graph_catalog::expression_parser::PropertyValue::Expression(expr) => {
+                expr.clone()
+            }
         };
         self.properties
             .push((prop.table_alias.0.clone(), property_name));

src/query_planner/plan_ctx/builder.rs

@@ -22,10 +22,8 @@ use std::{
 use crate::{
     graph_catalog::{graph_schema::GraphSchema, pattern_schema::PatternSchemaContext},
     query_planner::{
-        analyzer::property_requirements::PropertyRequirements,
-        join_context::VlpEndpointInfo,
-        logical_plan::ProjectionItem,
-        typed_variable::VariableRegistry,
+        analyzer::property_requirements::PropertyRequirements, join_context::VlpEndpointInfo,
+        logical_plan::ProjectionItem, typed_variable::VariableRegistry,
     },
 };
 
@@ -37,14 +35,14 @@ use super::{PlanCtx, TableCtx};
 pub struct PlanCtxBuilder {
     // Required
     schema: Arc<GraphSchema>,
-    
+
     // Optional with defaults
     tenant_id: Option<String>,
     view_parameter_values: Option<HashMap<String, String>>,
     max_inferred_types: usize,
     parent_scope: Option<Box<PlanCtx>>,
     is_with_scope: bool,
-    
+
     // Internal state (typically defaults)
     alias_table_ctx_map: HashMap<String, TableCtx>,
     optional_aliases: HashSet<String>,
@@ -80,7 +78,7 @@ impl PlanCtxBuilder {
             cte_alias_sources: HashMap::new(),
         }
     }
-    
+
     /// Create a builder from a parent scope (for WITH clause scoping).
     /// Inherits schema, tenant_id, view_parameters, and vlp_endpoints.
     pub fn from_parent(parent: &PlanCtx, is_with_scope: bool) -> Self {
@@ -103,85 +101,85 @@ impl PlanCtxBuilder {
             cte_alias_sources: HashMap::new(),
         }
     }
-    
+
     /// Set the tenant ID for multi-tenant deployments.
     pub fn tenant_id(mut self, tenant_id: impl Into<String>) -> Self {
         self.tenant_id = Some(tenant_id.into());
         self
     }
-    
+
     /// Set the tenant ID optionally.
     pub fn tenant_id_opt(mut self, tenant_id: Option<String>) -> Self {
         self.tenant_id = tenant_id;
         self
     }
-    
+
     /// Set view parameter values for parameterized views.
     pub fn view_parameters(mut self, params: HashMap<String, String>) -> Self {
         self.view_parameter_values = Some(params);
         self
     }
-    
+
     /// Set view parameter values optionally.
     pub fn view_parameters_opt(mut self, params: Option<HashMap<String, String>>) -> Self {
         self.view_parameter_values = params;
         self
     }
-    
+
     /// Set maximum number of inferred edge types.
     pub fn max_inferred_types(mut self, max: usize) -> Self {
         self.max_inferred_types = max;
         self
     }
-    
+
     /// Mark this scope as a WITH scope (barrier for variable lookup).
     pub fn as_with_scope(mut self) -> Self {
         self.is_with_scope = true;
         self
     }
-    
+
     /// Set the parent scope explicitly.
     pub fn parent_scope(mut self, parent: PlanCtx) -> Self {
         self.parent_scope = Some(Box::new(parent));
         self
     }
-    
+
     /// Initialize with existing table contexts.
     pub fn with_table_contexts(mut self, contexts: HashMap<String, TableCtx>) -> Self {
         self.alias_table_ctx_map = contexts;
         self
     }
-    
+
     /// Initialize with existing optional aliases.
     pub fn with_optional_aliases(mut self, aliases: HashSet<String>) -> Self {
         self.optional_aliases = aliases;
         self
     }
-    
+
     /// Set the CTE counter (for generating unique CTE names).
     pub fn cte_counter(mut self, counter: usize) -> Self {
         self.cte_counter = counter;
         self
     }
-    
+
     /// Set property requirements.
     pub fn property_requirements(mut self, requirements: PropertyRequirements) -> Self {
         self.property_requirements = Some(requirements);
         self
     }
-    
+
     /// Set VLP endpoints.
     pub fn vlp_endpoints(mut self, endpoints: HashMap<String, VlpEndpointInfo>) -> Self {
         self.vlp_endpoints = endpoints;
         self
     }
-    
+
     /// Set the variable registry.
     pub fn variables(mut self, registry: VariableRegistry) -> Self {
         self.variables = registry;
         self
     }
-    
+
     /// Build the PlanCtx instance.
     pub fn build(self) -> PlanCtx {
         PlanCtx {
@@ -211,7 +209,7 @@ impl PlanCtxBuilder {
 #[cfg(test)]
 mod tests {
     use super::*;
-    
+
     fn make_test_schema() -> Arc<GraphSchema> {
         Arc::new(GraphSchema::build(
             1,
@@ -220,67 +218,63 @@ mod tests {
             HashMap::new(),
         ))
     }
-    
+
     #[test]
     fn test_builder_minimal() {
         let schema = make_test_schema();
         let ctx = PlanCtxBuilder::new(schema.clone()).build();
-        
+
         assert_eq!(ctx.schema().database(), "test");
         assert!(ctx.tenant_id.is_none());
         assert_eq!(ctx.max_inferred_types, 5);
     }
-    
+
     #[test]
     fn test_builder_with_tenant() {
         let schema = make_test_schema();
-        let ctx = PlanCtxBuilder::new(schema)
-            .tenant_id("tenant-123")
-            .build();
-        
+        let ctx = PlanCtxBuilder::new(schema).tenant_id("tenant-123").build();
+
         assert_eq!(ctx.tenant_id, Some("tenant-123".to_string()));
     }
-    
+
     #[test]
     fn test_builder_with_all_params() {
         let schema = make_test_schema();
         let mut params = HashMap::new();
         params.insert("region".to_string(), "US".to_string());
-        
+
         let ctx = PlanCtxBuilder::new(schema)
             .tenant_id("tenant-123")
             .view_parameters(params.clone())
             .max_inferred_types(10)
             .build();
-        
+
         assert_eq!(ctx.tenant_id, Some("tenant-123".to_string()));
         assert_eq!(ctx.view_parameter_values, Some(params));
         assert_eq!(ctx.max_inferred_types, 10);
     }
-    
+
     #[test]
     fn test_builder_from_parent() {
         let schema = make_test_schema();
         let parent = PlanCtxBuilder::new(schema.clone())
             .tenant_id("parent-tenant")
             .max_inferred_types(15)
             .build();
-        
+
         let child = PlanCtxBuilder::from_parent(&parent, true).build();
-        
+
         assert_eq!(child.tenant_id, Some("parent-tenant".to_string()));
         assert_eq!(child.max_inferred_types, 15);
         assert!(child.is_with_scope);
         assert!(child.parent_scope.is_some());
     }
-    
+
     #[test]
     fn test_builder_as_with_scope() {
         let schema = make_test_schema();
-        let ctx = PlanCtxBuilder::new(schema)
-            .as_with_scope()
-            .build();
-        
+        let ctx = PlanCtxBuilder::new(schema).as_with_scope().build();
+
         assert!(ctx.is_with_scope);
     }
 }