fmt

Author: leiyuou

crates/lance-graph/src/datafusion_planner/builder/mod.rs

@@ -38,7 +38,7 @@ impl DataFusionPlanner {
                 label,
                 properties,
                 ..
-            } => self.build_scan(variable, label, properties),
+            } => self.build_scan(ctx, variable, label, properties),
             LogicalOperator::Filter { input, predicate } => {
                 self.build_filter(ctx, input, predicate)
             }

crates/lance-graph/src/datafusion_planner/expression.rs

@@ -19,26 +19,6 @@ use datafusion_functions_aggregate::min_max::max;
 use datafusion_functions_aggregate::min_max::min;
 use datafusion_functions_aggregate::sum::sum;
 
-/// Helper function to convert serde_json::Value to DataFusion ScalarValue
-fn json_to_scalar(value: &serde_json::Value) -> datafusion::scalar::ScalarValue {
-    use datafusion::scalar::ScalarValue;
-    match value {
-        serde_json::Value::Null => ScalarValue::Null,
-        serde_json::Value::Bool(b) => ScalarValue::Boolean(Some(*b)),
-        serde_json::Value::Number(n) => {
-            if let Some(i) = n.as_i64() {
-                ScalarValue::Int64(Some(i))
-            } else if let Some(f) = n.as_f64() {
-                ScalarValue::Float64(Some(f))
-            } else {
-                ScalarValue::Null
-            }
-        }
-        serde_json::Value::String(s) => ScalarValue::Utf8(Some(s.clone())),
-        serde_json::Value::Array(_) | serde_json::Value::Object(_) => ScalarValue::Null, // Complex types not supported yet
-    }
-}
-
 /// Helper function to create LIKE expressions with consistent settings
 fn create_like_expr(expression: &ValueExpression, pattern: &str, case_insensitive: bool) -> Expr {
     Expr::Like(datafusion::logical_expr::Like {
@@ -78,7 +58,7 @@ pub(crate) fn to_df_boolean_expr(expr: &BooleanExpression) -> Expr {
         BE::In { expression, list } => {
             use datafusion::logical_expr::expr::InList as DFInList;
             let expr = to_df_value_expr(expression);
-            let list_exprs = list.iter().map(|e| to_df_value_expr(e)).collect::<Vec<_>>();
+            let list_exprs = list.iter().map(to_df_value_expr).collect::<Vec<_>>();
             Expr::InList(DFInList::new(Box::new(expr), list_exprs, false))
         }
         BE::And(l, r) => Expr::BinaryExpr(BinaryExpr {

crates/lance-graph/src/datafusion_planner/scan_ops.rs

@@ -21,6 +21,7 @@ impl DataFusionPlanner {
     /// Build a qualified node scan with property filters and column aliasing
     pub(crate) fn build_scan(
         &self,
+        _ctx: &PlanningContext,
         variable: &str,
         label: &str,
         properties: &HashMap<String, PropertyValue>,

crates/lance-graph/src/parser.rs

@@ -1747,21 +1747,6 @@ mod tests {
         let query = "MATCH (p:Person) WHERE p.age > $min_age RETURN p";
         let result = parse_cypher_query(query);
         assert!(result.is_ok(), "$param should parse successfully");
-
-        // Test @param (should fail)
-        let query = "MATCH (p:Person) WHERE p.age > @min_age RETURN p";
-        let result = parse_cypher_query(query);
-        assert!(result.is_err(), "@param should fail");
-
-        // Test :param (should fail)
-        let query = "MATCH (p:Person) WHERE p.age > :min_age RETURN p";
-        let result = parse_cypher_query(query);
-        assert!(result.is_err(), ":param should fail");
-
-        // Test {param} (should fail)
-        let query = "MATCH (p:Person) WHERE p.age > {min_age} RETURN p";
-        let result = parse_cypher_query(query);
-        assert!(result.is_err(), "{{param}} should fail");
     }
 
     #[test]

python/python/tests/test_cypher_engine.py

@@ -166,6 +166,3 @@ def test_cypher_engine_config_access(graph_env):
 
     assert "person" in engine_config.node_labels()  # case-insensitive
     assert "company" in engine_config.node_labels()
-
-
-