gqlite 1.8.1 → 1.8.2

data/ext/gqlitedb/src/tests/planner.rs

@@ -53,6 +53,8 @@ fn test_plan_match_creates_scan_and_filter()
         variable: Some(node_identifier.clone()),
         labels: LabelExpression::String("Person".into()),
         properties: None,
+
+        predicate: None,
       })],
       where_expression: Some(
         Variable {
@@ -74,7 +76,7 @@ fn test_plan_match_creates_scan_and_filter()
     LogicalPlan::NodeScan { patterns, optional: true }
       if matches!(
         &patterns[0],
-        Pattern::Node(NodePattern {
+        planner::PlannedPattern::Node(NodePattern {
           labels: LabelExpression::String(label),
           ..
         }) if label == "Person"
@@ -221,6 +223,8 @@ fn test_plan_maps_direct_statements()
           variable: Some(node_identifier.clone()),
           labels: LabelExpression::None,
           properties: None,
+
+          predicate: None,
         })],
       }
       .into(),
@@ -340,6 +344,8 @@ fn test_plan_match_with_search_emits_vector_search()
         variable: Some(node_identifier.clone()),
         labels: LabelExpression::String("Doc".into()),
         properties: None,
+
+        predicate: None,
       })],
       where_expression: None,
       optional: false,
@@ -391,6 +397,8 @@ fn test_plan_match_with_search_and_score()
         variable: Some(node_identifier.clone()),
         labels: LabelExpression::String("Doc".into()),
         properties: None,
+
+        predicate: None,
       })],
       where_expression: None,
       optional: false,
@@ -440,6 +448,8 @@ fn test_plan_match_without_search_still_emits_node_scan()
         variable: Some(node_identifier.clone()),
         labels: LabelExpression::String("Person".into()),
         properties: None,
+
+        predicate: None,
       })],
       where_expression: None,
       optional: false,
@@ -457,7 +467,7 @@ fn test_plan_match_without_search_still_emits_node_scan()
     }
       if matches!(
         &patterns[0],
-        Pattern::Node(NodePattern {
+        planner::PlannedPattern::Node(NodePattern {
           labels: LabelExpression::String(label),
           ..
         }) if label == "Person"
@@ -477,6 +487,8 @@ fn test_plan_match_with_search_and_filter()
         variable: Some(node_identifier.clone()),
         labels: LabelExpression::String("Doc".into()),
         properties: None,
+
+        predicate: None,
       })],
       where_expression: Some(Value { value: true.into() }.into()),
       optional: false,
@@ -510,3 +522,421 @@ fn test_plan_match_with_search_and_filter()
         && *k == 3
   ));
 }
+
+#[test]
+fn test_choose_path_strategy_all_to_dfs()
+{
+  let selector = PathSelector::All;
+  assert_eq!(
+    planner::choose_path_strategy(&selector),
+    planner::PathStrategy::Dfs
+  );
+}
+
+#[test]
+fn test_choose_path_strategy_any_to_bfs()
+{
+  let selector = PathSelector::Any;
+  assert_eq!(
+    planner::choose_path_strategy(&selector),
+    planner::PathStrategy::Bfs {
+      stop_condition: planner::StopCondition::Shortest(Value { value: 1i64.into() }.into()),
+    }
+  );
+}
+
+#[test]
+fn test_choose_path_strategy_all_shortest_to_bfs()
+{
+  let selector = PathSelector::AllShortest;
+  assert_eq!(
+    planner::choose_path_strategy(&selector),
+    planner::PathStrategy::Bfs {
+      stop_condition: planner::StopCondition::ShortestGroups(Value { value: 1i64.into() }.into()),
+    }
+  );
+}
+
+#[test]
+fn test_choose_path_strategy_shortest_to_bfs()
+{
+  let selector = PathSelector::Shortest(Value { value: 10.into() }.into());
+  assert_eq!(
+    planner::choose_path_strategy(&selector),
+    planner::PathStrategy::Bfs {
+      stop_condition: planner::StopCondition::Shortest(Value { value: 10.into() }.into()),
+    }
+  );
+}
+
+#[test]
+fn test_choose_path_strategy_shortest_groups_to_bfs()
+{
+  let selector = PathSelector::ShortestGroups(Value { value: 5.into() }.into());
+  assert_eq!(
+    planner::choose_path_strategy(&selector),
+    planner::PathStrategy::Bfs {
+      stop_condition: planner::StopCondition::ShortestGroups(Value { value: 5.into() }.into()),
+    }
+  );
+}
+
+#[test]
+fn test_plan_pattern_node_passes_through()
+{
+  let identifiers = VariableIdentifiers::default();
+  let n_identifier = identifiers.create_variable_from_name("n");
+
+  let node_pattern = Pattern::Node(NodePattern {
+    variable: Some(n_identifier.clone()),
+    labels: LabelExpression::String("Person".into()),
+    properties: None,
+    predicate: None,
+  });
+
+  let planned = planner::plan_pattern(node_pattern);
+  assert!(matches!(planned, planner::PlannedPattern::Node(_)));
+}
+
+#[test]
+fn test_plan_pattern_edge_passes_through()
+{
+  let node_a = NodePattern {
+    variable: None,
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+  let node_b = NodePattern {
+    variable: None,
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let edge_pattern = Pattern::Edge(EdgePattern {
+    variable: None,
+    source: node_a,
+    destination: node_b,
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::String("R".into()),
+    properties: None,
+    predicate: None,
+  });
+
+  let planned = planner::plan_pattern(edge_pattern);
+  assert!(matches!(planned, planner::PlannedPattern::Edge(_)));
+}
+
+#[test]
+fn test_plan_pattern_quantified_path_uses_dfs_for_all()
+{
+  let identifiers = VariableIdentifiers::default();
+  let node_a = NodePattern {
+    variable: Some(identifiers.create_variable_from_name("a")),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+  let node_b = NodePattern {
+    variable: None,
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let qp_source = node_a.clone();
+  let qp_destination = node_b.clone();
+  let edge_pattern = EdgePattern {
+    variable: None,
+    source: node_a,
+    destination: node_b,
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::String("R".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  let quantified_pattern = Pattern::QuantifiedPath(QuantifiedPathPattern {
+    variable: None,
+    source: qp_source,
+    group: vec![Pattern::Edge(edge_pattern)],
+    group_where: None,
+    path_where: None,
+    quantifier: Some(1..3),
+    destination: qp_destination,
+    selector: PathSelector::All,
+  });
+
+  let planned = planner::plan_pattern(quantified_pattern);
+  assert!(matches!(
+    planned,
+    planner::PlannedPattern::QuantifiedPath { strategy, .. }
+      if strategy == planner::PathStrategy::Dfs
+  ));
+}
+
+#[test]
+fn test_plan_pattern_quantified_path_uses_bfs_for_shortest()
+{
+  let identifiers = VariableIdentifiers::default();
+  let node_a = NodePattern {
+    variable: Some(identifiers.create_variable_from_name("a")),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+  let node_b = NodePattern {
+    variable: None,
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let qp_source = node_a.clone();
+  let qp_destination = node_b.clone();
+  let edge_pattern = EdgePattern {
+    variable: None,
+    source: node_a,
+    destination: node_b,
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::String("R".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  let quantified_pattern = Pattern::QuantifiedPath(QuantifiedPathPattern {
+    variable: None,
+    source: qp_source,
+    group: vec![Pattern::Edge(edge_pattern)],
+    group_where: None,
+    path_where: None,
+    quantifier: Some(1..3),
+    destination: qp_destination,
+    selector: PathSelector::Shortest(Value { value: 1.into() }.into()),
+  });
+
+  let planned = planner::plan_pattern(quantified_pattern);
+  assert!(matches!(
+    planned,
+    planner::PlannedPattern::QuantifiedPath { strategy, .. }
+      if matches!(strategy, planner::PathStrategy::Bfs { stop_condition: planner::StopCondition::Shortest(_) })
+  ));
+}
+
+#[test]
+fn test_wrapper_around_plain_edge_promotes_to_degenerate_quantifier()
+{
+  let identifiers = VariableIdentifiers::default();
+  let node_a = NodePattern {
+    variable: Some(identifiers.create_variable_from_name("a")),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+  let node_b = NodePattern {
+    variable: None,
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let qp_source = node_a.clone();
+  let qp_destination = node_b.clone();
+  let edge_pattern = EdgePattern {
+    variable: None,
+    source: node_a,
+    destination: node_b,
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::String("R".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  // Wrapper pattern with quantifier: None (the scoping wrapper)
+  let wrapper = QuantifiedPathPattern {
+    variable: None,
+    source: qp_source,
+    group: vec![Pattern::Edge(edge_pattern)],
+    group_where: None,
+    path_where: None,
+    quantifier: None,
+    destination: qp_destination,
+    selector: PathSelector::Shortest(Value { value: 1.into() }.into()),
+  };
+
+  let planned = planner::plan_pattern(Pattern::QuantifiedPath(wrapper));
+
+  // Assert: the result should be a QuantifiedPath with promoted quantifier and outer strategy
+  match planned
+  {
+    planner::PlannedPattern::QuantifiedPath { pattern, strategy } =>
+    {
+      // Check quantifier was promoted to exactly-one repetition (1..1)
+      assert_eq!(
+        pattern.quantifier,
+        Some(1..1),
+        "quantifier should be promoted to Some(1..1)"
+      );
+
+      // Check strategy matches the outer selector (Shortest with literal 1)
+      assert!(
+        matches!(
+          strategy,
+          planner::PathStrategy::Bfs {
+            stop_condition: planner::StopCondition::Shortest(_)
+          }
+        ),
+        "strategy should be Bfs with Shortest stop condition"
+      );
+    }
+    _ => panic!("expected PlannedPattern::QuantifiedPath"),
+  }
+}
+
+#[test]
+fn test_wrapper_around_quantified_path_preserves_inner_quantifier_and_applies_outer_strategy()
+{
+  let identifiers = VariableIdentifiers::default();
+  let node_a = NodePattern {
+    variable: Some(identifiers.create_variable_from_name("a")),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+  let node_b = NodePattern {
+    variable: None,
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let qp_source = node_a.clone();
+  let qp_destination = node_b.clone();
+  let edge_pattern = EdgePattern {
+    variable: None,
+    source: node_a,
+    destination: node_b,
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::String("R".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  // Inner already-quantified pattern (simulating `--+`)
+  let inner_quantified = QuantifiedPathPattern {
+    variable: None,
+    source: qp_source.clone(),
+    group: vec![Pattern::Edge(edge_pattern)],
+    group_where: None,
+    path_where: None,
+    quantifier: Some(1..usize::MAX),
+    destination: qp_destination.clone(),
+    selector: PathSelector::All,
+  };
+
+  // Outer wrapper with quantifier: None (scoping wrapper)
+  let wrapper = QuantifiedPathPattern {
+    variable: None,
+    source: qp_source,
+    group: vec![Pattern::QuantifiedPath(inner_quantified)],
+    group_where: None,
+    path_where: None,
+    quantifier: None,
+    destination: qp_destination,
+    selector: PathSelector::Shortest(Value { value: 1.into() }.into()),
+  };
+
+  let planned = planner::plan_pattern(Pattern::QuantifiedPath(wrapper));
+
+  // Assert: inner quantifier is preserved, but strategy is from outer selector
+  match planned
+  {
+    planner::PlannedPattern::QuantifiedPath { pattern, strategy } =>
+    {
+      // Check inner quantifier was preserved (1..usize::MAX)
+      assert_eq!(
+        pattern.quantifier,
+        Some(1..usize::MAX),
+        "inner quantifier should be preserved"
+      );
+
+      // Check strategy is from outer selector, not inner's All/Dfs
+      assert!(
+        matches!(
+          strategy,
+          planner::PathStrategy::Bfs {
+            stop_condition: planner::StopCondition::Shortest(_)
+          }
+        ),
+        "strategy should be Bfs (from outer), not Dfs (from inner All)"
+      );
+    }
+    _ => panic!("expected PlannedPattern::QuantifiedPath"),
+  }
+}
+
+#[test]
+fn test_wrapper_with_group_where_is_preserved()
+{
+  let identifiers = VariableIdentifiers::default();
+  let node_a = NodePattern {
+    variable: Some(identifiers.create_variable_from_name("a")),
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+  let node_b = NodePattern {
+    variable: None,
+    labels: LabelExpression::None,
+    properties: None,
+    predicate: None,
+  };
+
+  let qp_source = node_a.clone();
+  let qp_destination = node_b.clone();
+  let edge_pattern = EdgePattern {
+    variable: None,
+    source: node_a,
+    destination: node_b,
+    directivity: graphcore::EdgeDirectivity::Directed,
+    labels: LabelExpression::String("R".into()),
+    properties: None,
+    predicate: None,
+  };
+
+  // Group where condition - using a simple Value expression
+  let group_where = Some(Value { value: true.into() }.into());
+
+  // Wrapper pattern with quantifier: None and group_where
+  let wrapper = QuantifiedPathPattern {
+    variable: None,
+    source: qp_source,
+    group: vec![Pattern::Edge(edge_pattern)],
+    group_where: group_where.clone(),
+    path_where: None,
+    quantifier: None,
+    destination: qp_destination,
+    selector: PathSelector::Shortest(Value { value: 1.into() }.into()),
+  };
+
+  let planned = planner::plan_pattern(Pattern::QuantifiedPath(wrapper));
+
+  // Assert: the result should have path_where set (wrapper predicate routes to path_where)
+  // and group_where should be None (wrapper-promoted patterns never have group_where)
+  match planned
+  {
+    planner::PlannedPattern::QuantifiedPath { pattern, .. } =>
+    {
+      assert!(
+        pattern.path_where.is_some(),
+        "path_where should contain the wrapper's predicate in the promoted pattern"
+      );
+      assert!(
+        pattern.group_where.is_none(),
+        "group_where should be None in wrapper-promoted patterns (predicates route to path_where)"
+      );
+    }
+    _ => panic!("expected PlannedPattern::QuantifiedPath"),
+  }
+}

data/ext/gqlitedb/src/tests/store/vector_index/postgres.rs

@@ -34,7 +34,7 @@ mod reopen
 #[test]
 fn test_postgres_node_update_syncs_to_vector_index()
 {
-  let db = create_tmp_db(274);
+  let db = create_tmp_db(290);
   let config: postgres::Config = db.connection_uri().parse().unwrap();
   let store = crate::store::postgres::Store::connect(config).unwrap();
   super::test_vector_updated_on_node_property_update(store);
@@ -43,7 +43,7 @@ fn test_postgres_node_update_syncs_to_vector_index()
 #[test]
 fn test_postgres_upsert_rejects_nan_component()
 {
-  let db = create_tmp_db(275);
+  let db = create_tmp_db(291);
   let config: postgres::Config = db.connection_uri().parse().unwrap();
   let store = crate::store::postgres::Store::connect(config).unwrap();
 
@@ -79,7 +79,7 @@ fn test_postgres_upsert_rejects_nan_component()
 #[test]
 fn test_postgres_upsert_rejects_inf_component()
 {
-  let db = create_tmp_db(276);
+  let db = create_tmp_db(292);
   let config: postgres::Config = db.connection_uri().parse().unwrap();
   let store = crate::store::postgres::Store::connect(config).unwrap();
 
@@ -115,7 +115,7 @@ fn test_postgres_upsert_rejects_inf_component()
 #[test]
 fn test_postgres_search_rejects_nan_query()
 {
-  let db = create_tmp_db(277);
+  let db = create_tmp_db(293);
   let config: postgres::Config = db.connection_uri().parse().unwrap();
   let store = crate::store::postgres::Store::connect(config).unwrap();
 
@@ -153,7 +153,7 @@ fn test_postgres_search_rejects_nan_query()
 #[test]
 fn test_postgres_delete_vectors_rejects_malformed_node_id()
 {
-  let db = create_tmp_db(278);
+  let db = create_tmp_db(294);
   let config: postgres::Config = db.connection_uri().parse().unwrap();
   let store = crate::store::postgres::Store::connect(config).unwrap();
 

data/ext/gqlitedb/src/tests/store/vector_index/sqlite.rs

@@ -33,7 +33,9 @@ fn test_sqlite_vector_binary_roundtrip()
   let blob: Vec<u8> = original.iter().flat_map(|f| f.to_le_bytes()).collect();
 
   let decoded: Vec<f32> = blob
-    .chunks_exact(4)
+    .as_chunks::<4>()
+    .0
+    .iter()
     .map(|b| f32::from_le_bytes([b[0], b[1], b[2], b[3]]))
     .collect();