gqlite 1.5.0 → 1.7.0

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

@@ -0,0 +1,511 @@
+use gqlparser::oc::ast::*;
+
+use crate::{LogicalPlan, ProjectionKind, planner};
+
+fn unwrap_filter(plan: &LogicalPlan) -> (&LogicalPlan, &Expression)
+{
+  match plan
+  {
+    LogicalPlan::Filter { source, expression } => (source, expression),
+    _ => panic!("expected filter"),
+  }
+}
+
+fn unwrap_sort(plan: &LogicalPlan) -> (&LogicalPlan, &[OrderByExpression])
+{
+  match plan
+  {
+    LogicalPlan::Sort {
+      source,
+      expressions,
+    } => (source, expressions),
+    _ => panic!("expected sort"),
+  }
+}
+
+fn unwrap_skip(plan: &LogicalPlan) -> (&LogicalPlan, &Expression)
+{
+  match plan
+  {
+    LogicalPlan::Skip { source, expression } => (source, expression),
+    _ => panic!("expected skip"),
+  }
+}
+
+fn unwrap_limit(plan: &LogicalPlan) -> (&LogicalPlan, &Expression)
+{
+  match plan
+  {
+    LogicalPlan::Limit { source, expression } => (source, expression),
+    _ => panic!("expected limit"),
+  }
+}
+
+#[test]
+fn test_plan_match_creates_scan_and_filter()
+{
+  let identifiers = VariableIdentifiers::default();
+  let node_identifier = identifiers.create_variable_from_name("n");
+
+  let plan = planner::plan(
+    Match {
+      patterns: vec![Pattern::Node(NodePattern {
+        variable: Some(node_identifier.clone()),
+        labels: LabelExpression::String("Person".into()),
+        properties: None,
+      })],
+      where_expression: Some(
+        Variable {
+          identifier: node_identifier,
+        }
+        .into(),
+      ),
+      optional: true,
+      search: None,
+    }
+    .into(),
+  )
+  .unwrap();
+
+  let (source, expression) = unwrap_filter(&plan);
+  assert!(matches!(expression, Expression::Variable(_)));
+  assert!(matches!(
+    source,
+    LogicalPlan::NodeScan { patterns, optional: true }
+      if matches!(
+        &patterns[0],
+        Pattern::Node(NodePattern {
+          labels: LabelExpression::String(label),
+          ..
+        }) if label == "Person"
+      )
+  ));
+}
+
+#[test]
+fn test_plan_return_creates_projection_modifier_chain()
+{
+  let identifiers = VariableIdentifiers::default();
+  let node_identifier = identifiers.create_variable_from_name("n");
+
+  let plan = planner::plan(
+    Return {
+      all: false,
+      expressions: vec![NamedExpression {
+        identifier: identifiers.create_variable_from_name("result"),
+        expression: Variable {
+          identifier: node_identifier.clone(),
+        }
+        .into(),
+      }],
+      modifiers: Modifiers {
+        skip: Some(Value { value: 2.into() }.into()),
+        limit: Some(Value { value: 4.into() }.into()),
+        order_by: Some(OrderBy {
+          expressions: vec![OrderByExpression {
+            asc: false,
+            expression: Variable {
+              identifier: node_identifier.clone(),
+            }
+            .into(),
+          }],
+        }),
+      },
+      where_expression: Some(
+        Variable {
+          identifier: node_identifier,
+        }
+        .into(),
+      ),
+    }
+    .into(),
+  )
+  .unwrap();
+
+  let (source, limit) = unwrap_limit(&plan);
+  assert!(matches!(limit, Expression::Value(Value { .. })));
+
+  let (source, skip) = unwrap_skip(source);
+  assert!(matches!(skip, Expression::Value(Value { .. })));
+
+  let (source, order_by) = unwrap_sort(source);
+  assert_eq!(order_by.len(), 1);
+  assert!(!order_by[0].asc);
+
+  let (source, expression) = unwrap_filter(source);
+  assert!(matches!(expression, Expression::Variable(_)));
+
+  assert!(matches!(
+    source,
+    LogicalPlan::Projection {
+      kind: ProjectionKind::Return,
+      all: false,
+      expressions,
+    } if expressions.len() == 1
+  ));
+}
+
+#[test]
+fn test_plan_with_creates_projection()
+{
+  let identifiers = VariableIdentifiers::default();
+
+  let plan = planner::plan(
+    With {
+      all: true,
+      expressions: vec![],
+      modifiers: Default::default(),
+      where_expression: None,
+    }
+    .into(),
+  )
+  .unwrap();
+
+  assert!(matches!(
+    plan,
+    LogicalPlan::Projection {
+      kind: ProjectionKind::With,
+      all: true,
+      expressions,
+    } if expressions.is_empty()
+  ));
+
+  let _ = identifiers;
+}
+
+#[test]
+fn test_plan_maps_direct_statements()
+{
+  let identifiers = VariableIdentifiers::default();
+  let node_identifier = identifiers.create_variable_from_name("n");
+
+  assert!(matches!(planner::plan(
+      CreateGraph {
+        name: "graph".into(),
+        if_not_exists: true,
+      }
+      .into(),
+    ).unwrap(),
+    LogicalPlan::CreateGraph {
+      name,
+      if_not_exists: true,
+    } if name == "graph"
+  ));
+
+  assert!(matches!(planner::plan(
+      DropGraph {
+        name: "graph".into(),
+        if_exists: true,
+      }
+      .into(),
+    ).unwrap(),
+    LogicalPlan::DropGraph {
+      name,
+      if_exists: true,
+    } if name == "graph"
+  ));
+
+  assert!(matches!(planner::plan(
+      UseGraph {
+        name: "graph".into(),
+      }
+      .into(),
+    ).unwrap(),
+    LogicalPlan::UseGraph { name } if name == "graph"
+  ));
+
+  assert!(matches!(planner::plan(
+      Create {
+        patterns: vec![Pattern::Node(NodePattern {
+          variable: Some(node_identifier.clone()),
+          labels: LabelExpression::None,
+          properties: None,
+        })],
+      }
+      .into(),
+    ).unwrap(),
+    LogicalPlan::Create { patterns } if patterns.len() == 1
+  ));
+
+  assert!(matches!(planner::plan(
+      Call {
+        name: "db.labels".into(),
+        arguments: vec![Value { value: 1.into() }.into()],
+      }
+      .into(),
+    ).unwrap(),
+    LogicalPlan::Call { name, arguments } if name == "db.labels" && arguments.len() == 1
+  ));
+
+  assert!(matches!(
+    planner::plan(
+      Unwind {
+        identifier: identifiers.create_variable_from_name("item"),
+        expression: Array {
+          array: vec![Value { value: 1.into() }.into()],
+        }
+        .into(),
+      }
+      .into(),
+    )
+    .unwrap(),
+    LogicalPlan::Unwind { .. }
+  ));
+
+  assert!(matches!(planner::plan(
+      Delete {
+        detach: true,
+        expressions: vec![
+          Variable {
+            identifier: node_identifier.clone(),
+          }
+          .into(),
+        ],
+      }
+      .into(),
+    ).unwrap(),
+    LogicalPlan::Delete {
+      detach: true,
+      expressions,
+    } if expressions.len() == 1
+  ));
+
+  assert!(matches!(planner::plan(
+      Update {
+        updates: vec![
+          OneUpdate::SetProperty(UpdateProperty {
+            target: node_identifier.clone(),
+            path: vec!["name".into()],
+            expression: Value {
+              value: "Alice".into(),
+            }
+            .into(),
+          }),
+          OneUpdate::RemoveProperty(RemoveProperty {
+            target: node_identifier,
+            path: vec!["age".into()],
+          }),
+        ],
+      }
+      .into(),
+    ).unwrap(),
+    LogicalPlan::Update { updates } if updates.len() == 2
+  ));
+}
+
+#[test]
+fn test_plan_create_vector_index()
+{
+  let plan = planner::plan(
+    CreateVectorIndex {
+      name: "doc_idx".into(),
+      label: "Doc".into(),
+      property: "embedding".into(),
+      dimension: Some(384),
+      metric: Some(Metric::Cosine),
+      if_not_exists: false,
+    }
+    .into(),
+  )
+  .unwrap();
+
+  assert!(matches!(
+    plan,
+    LogicalPlan::CreateVectorIndex {
+      name,
+      label,
+      property,
+      dimension,
+      metric,
+      if_not_exists: false,
+    }
+      if name == "doc_idx"
+        && label == "Doc"
+        && property == "embedding"
+        && dimension == Some(384)
+        && metric == Some(Metric::Cosine)
+  ));
+}
+
+#[test]
+fn test_plan_match_with_search_emits_vector_search()
+{
+  let identifiers = VariableIdentifiers::default();
+  let node_identifier = identifiers.create_variable_from_name("n");
+
+  let plan = planner::plan(
+    Match {
+      patterns: vec![Pattern::Node(NodePattern {
+        variable: Some(node_identifier.clone()),
+        labels: LabelExpression::String("Doc".into()),
+        properties: None,
+      })],
+      where_expression: None,
+      optional: false,
+      search: Some(Search {
+        variable: node_identifier.clone(),
+        index: "doc_idx".into(),
+        query: Array {
+          array: vec![
+            Value { value: 0.1.into() }.into(),
+            Value { value: 0.2.into() }.into(),
+            Value { value: 0.3.into() }.into(),
+          ],
+        }
+        .into(),
+        limit: 5,
+        score_alias: None,
+      }),
+    }
+    .into(),
+  )
+  .unwrap();
+
+  assert!(matches!(
+    plan,
+    LogicalPlan::VectorSearch {
+      index,
+      k,
+      result_var,
+      score_var,
+      ..
+    }
+      if index == "doc_idx"
+        && k == 5
+        && result_var.name() == "n"
+        && score_var.is_none()
+  ));
+}
+
+#[test]
+fn test_plan_match_with_search_and_score()
+{
+  let identifiers = VariableIdentifiers::default();
+  let node_identifier = identifiers.create_variable_from_name("n");
+  let score_identifier = identifiers.create_variable_from_name("score");
+
+  let plan = planner::plan(
+    Match {
+      patterns: vec![Pattern::Node(NodePattern {
+        variable: Some(node_identifier.clone()),
+        labels: LabelExpression::String("Doc".into()),
+        properties: None,
+      })],
+      where_expression: None,
+      optional: false,
+      search: Some(Search {
+        variable: node_identifier.clone(),
+        index: "doc_idx".into(),
+        query: Array {
+          array: vec![
+            Value { value: 0.1.into() }.into(),
+            Value { value: 0.2.into() }.into(),
+          ],
+        }
+        .into(),
+        limit: 10,
+        score_alias: Some(score_identifier.clone()),
+      }),
+    }
+    .into(),
+  )
+  .unwrap();
+
+  assert!(matches!(
+    plan,
+    LogicalPlan::VectorSearch {
+      index,
+      k,
+      result_var,
+      score_var,
+      ..
+    }
+      if index == "doc_idx"
+        && k == 10
+        && result_var.name() == "n"
+        && score_var.as_ref().unwrap().name() == "score"
+  ));
+}
+
+#[test]
+fn test_plan_match_without_search_still_emits_node_scan()
+{
+  let identifiers = VariableIdentifiers::default();
+  let node_identifier = identifiers.create_variable_from_name("n");
+
+  let plan = planner::plan(
+    Match {
+      patterns: vec![Pattern::Node(NodePattern {
+        variable: Some(node_identifier.clone()),
+        labels: LabelExpression::String("Person".into()),
+        properties: None,
+      })],
+      where_expression: None,
+      optional: false,
+      search: None,
+    }
+    .into(),
+  )
+  .unwrap();
+
+  assert!(matches!(
+    plan,
+    LogicalPlan::NodeScan {
+      patterns,
+      optional: false,
+    }
+      if matches!(
+        &patterns[0],
+        Pattern::Node(NodePattern {
+          labels: LabelExpression::String(label),
+          ..
+        }) if label == "Person"
+      )
+  ));
+}
+
+#[test]
+fn test_plan_match_with_search_and_filter()
+{
+  let identifiers = VariableIdentifiers::default();
+  let node_identifier = identifiers.create_variable_from_name("n");
+
+  let plan = planner::plan(
+    Match {
+      patterns: vec![Pattern::Node(NodePattern {
+        variable: Some(node_identifier.clone()),
+        labels: LabelExpression::String("Doc".into()),
+        properties: None,
+      })],
+      where_expression: Some(Value { value: true.into() }.into()),
+      optional: false,
+      search: Some(Search {
+        variable: node_identifier.clone(),
+        index: "doc_idx".into(),
+        query: Array {
+          array: vec![
+            Value { value: 0.5.into() }.into(),
+            Value { value: 0.6.into() }.into(),
+          ],
+        }
+        .into(),
+        limit: 3,
+        score_alias: None,
+      }),
+    }
+    .into(),
+  )
+  .unwrap();
+
+  let (source, _) = unwrap_filter(&plan);
+  assert!(matches!(
+    source,
+    LogicalPlan::VectorSearch {
+      index,
+      k,
+      ..
+    }
+      if index == "doc_idx"
+        && *k == 3
+  ));
+}

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

@@ -39,3 +39,10 @@ fn test_update_edges()
   let (store, _db) = create_test_store(104);
   super::test_update_edges(store);
 }
+
+#[test]
+fn test_select_nodes_by_uuids()
+{
+  let (store, _db) = create_test_store(105);
+  super::test_select_nodes_by_uuids(store);
+}

data/ext/gqlitedb/src/tests/store/redb.rs

@@ -44,3 +44,11 @@ fn test_update_edges()
   let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
   super::test_update_edges(store);
 }
+
+#[test]
+fn test_select_nodes_by_uuids()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
+  super::test_select_nodes_by_uuids(store);
+}

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

@@ -44,3 +44,11 @@ fn test_update_edges()
   let store = crate::store::sqlite::Store::open(temp_file.path()).unwrap();
   super::test_update_edges(store);
 }
+
+#[test]
+fn test_select_nodes_by_uuids()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  let store = crate::store::sqlite::Store::open(temp_file.path()).unwrap();
+  super::test_select_nodes_by_uuids(store);
+}

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

@@ -0,0 +1,182 @@
+use crate::store::sqlbase::SqlStore;
+use crate::store::{Store, TransactionBoxable};
+use crate::tests::postgres::create_tmp_db;
+
+mod single_open
+{
+  crate::vector_index_test_suite!(
+    setup = |idx: u16| {
+      let db = crate::tests::postgres::create_tmp_db(250 + idx);
+      let config: postgres::Config = db.connection_uri().parse().unwrap();
+      let store = crate::store::postgres::Store::connect(config).unwrap();
+      (db, store)
+    }
+  );
+}
+
+mod reopen
+{
+  crate::vector_index_reopen_suite!(
+    setup = |idx: u16| {
+      let db = crate::tests::postgres::create_tmp_db(280 + idx);
+      let uri = db.connection_uri();
+      let factory = move || {
+        let config: postgres::Config = uri.parse().unwrap();
+        crate::store::postgres::Store::connect(config).unwrap()
+      };
+      (db, factory)
+    }
+  );
+}
+
+// PostgreSQL-specific tests (not part of the generic suite)
+
+#[test]
+fn test_postgres_node_update_syncs_to_vector_index()
+{
+  let db = create_tmp_db(274);
+  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);
+}
+
+#[test]
+fn test_postgres_upsert_rejects_nan_component()
+{
+  let db = create_tmp_db(275);
+  let config: postgres::Config = db.connection_uri().parse().unwrap();
+  let store = crate::store::postgres::Store::connect(config).unwrap();
+
+  let mut tx = store.begin_write().unwrap();
+  store
+    .create_vector_index(
+      &mut tx,
+      "default",
+      crate::store::VectorIndexSpec {
+        name: "idx".into(),
+        dimension: 3,
+        metric: crate::store::VectorMetric::Cosine,
+        ..Default::default()
+      },
+    )
+    .unwrap();
+
+  let result = store.upsert_vector(
+    &mut tx,
+    "default",
+    "idx",
+    crate::graph::Key::new(1),
+    &crate::value::Tensor::from_f32_slice(&[1.0, f32::NAN, 0.0]),
+  );
+  tx.close().unwrap();
+
+  assert!(result.is_err());
+  let message = result.unwrap_err().to_string().to_lowercase();
+  assert!(!message.contains("pgvector"));
+  assert!(!message.contains("pg_catalog"));
+}
+
+#[test]
+fn test_postgres_upsert_rejects_inf_component()
+{
+  let db = create_tmp_db(276);
+  let config: postgres::Config = db.connection_uri().parse().unwrap();
+  let store = crate::store::postgres::Store::connect(config).unwrap();
+
+  let mut tx = store.begin_write().unwrap();
+  store
+    .create_vector_index(
+      &mut tx,
+      "default",
+      crate::store::VectorIndexSpec {
+        name: "idx".into(),
+        dimension: 3,
+        metric: crate::store::VectorMetric::Cosine,
+        ..Default::default()
+      },
+    )
+    .unwrap();
+
+  let result = store.upsert_vector(
+    &mut tx,
+    "default",
+    "idx",
+    crate::graph::Key::new(1),
+    &crate::value::Tensor::from_f32_slice(&[1.0, f32::INFINITY, 0.0]),
+  );
+  tx.close().unwrap();
+
+  assert!(result.is_err());
+  let message = result.unwrap_err().to_string().to_lowercase();
+  assert!(!message.contains("pgvector"));
+  assert!(!message.contains("pg_catalog"));
+}
+
+#[test]
+fn test_postgres_search_rejects_nan_query()
+{
+  let db = create_tmp_db(277);
+  let config: postgres::Config = db.connection_uri().parse().unwrap();
+  let store = crate::store::postgres::Store::connect(config).unwrap();
+
+  let mut tx = store.begin_write().unwrap();
+  store
+    .create_vector_index(
+      &mut tx,
+      "default",
+      crate::store::VectorIndexSpec {
+        name: "idx".into(),
+        dimension: 3,
+        metric: crate::store::VectorMetric::Cosine,
+        ..Default::default()
+      },
+    )
+    .unwrap();
+  tx.close().unwrap();
+
+  let mut tx = store.begin_read().unwrap();
+  let result = store.vector_search(
+    &mut tx,
+    "default",
+    "idx",
+    &crate::value::Tensor::from_f32_slice(&[1.0, f32::NAN, 0.0]),
+    5,
+  );
+  tx.close().unwrap();
+
+  assert!(result.is_err());
+  let message = result.unwrap_err().to_string().to_lowercase();
+  assert!(!message.contains("pgvector"));
+  assert!(!message.contains("pg_catalog"));
+}
+
+#[test]
+fn test_postgres_delete_vectors_rejects_malformed_node_id()
+{
+  let db = create_tmp_db(278);
+  let config: postgres::Config = db.connection_uri().parse().unwrap();
+  let store = crate::store::postgres::Store::connect(config).unwrap();
+
+  let mut tx = store.begin_write().unwrap();
+  store
+    .create_vector_index(
+      &mut tx,
+      "default",
+      crate::store::VectorIndexSpec {
+        name: "idx".into(),
+        dimension: 3,
+        metric: crate::store::VectorMetric::Cosine,
+        ..Default::default()
+      },
+    )
+    .unwrap();
+
+  let result = store.delete_vectors_for_nodes_impl(&mut tx, "default", &[String::from("not-hex")]);
+  tx.close().unwrap();
+
+  assert!(result.is_err());
+  assert!(
+    result.unwrap_err().to_string().contains("invalid node_id"),
+    "malformed node id should return a typed invalid node_id error"
+  );
+}