gqlite 1.5.0 → 1.7.0

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

@@ -0,0 +1,386 @@
+mod in_memory
+{
+  crate::vector_index_test_suite!(
+    setup = |_| ((), crate::store::redb::Store::in_memory().unwrap())
+  );
+}
+
+mod file_backed
+{
+  crate::vector_index_test_suite!(
+    setup = |_| {
+      let tmp = crate::tests::create_tmp_file();
+      let path = tmp.path().to_path_buf();
+      let store = crate::store::redb::Store::open(path.as_path()).unwrap();
+      (tmp, store)
+    }
+  );
+}
+
+mod reopen
+{
+  crate::vector_index_reopen_suite!(
+    setup = |_| {
+      let tmp = crate::tests::create_tmp_file();
+      let path = tmp.path().to_owned();
+      let factory = move || crate::store::redb::Store::open(&path).unwrap();
+      (tmp, factory)
+    }
+  );
+}
+
+mod redb_specific
+{
+  use crate::store::{Store, TransactionBoxable, VectorIndexSpec, VectorMetric};
+  use serial_test::serial;
+
+  #[test]
+  fn test_delete_persists_tombstone_without_reload()
+  {
+    let store = crate::store::redb::Store::in_memory().unwrap();
+    let graph_name = "delete_persist_no_reload";
+    let index_name = "idx";
+
+    let node_a = crate::graph::Node::new(
+      Some(graph_name.into()),
+      crate::graph::Key::new(1),
+      crate::graph::labels!("Item"),
+      crate::value::ValueMap::new(),
+    );
+    let node_b = crate::graph::Node::new(
+      Some(graph_name.into()),
+      crate::graph::Key::new(2),
+      crate::graph::labels!("Item"),
+      crate::value::ValueMap::new(),
+    );
+
+    let mut tx = store.begin_write().unwrap();
+    store.create_graph(&mut tx, graph_name, false).unwrap();
+    store
+      .create_vector_index(
+        &mut tx,
+        graph_name,
+        VectorIndexSpec {
+          name: index_name.into(),
+          dimension: 3,
+          metric: VectorMetric::Cosine,
+          ..Default::default()
+        },
+      )
+      .unwrap();
+    store
+      .create_nodes(&mut tx, graph_name, [&node_a, &node_b])
+      .unwrap();
+    store
+      .upsert_vector(
+        &mut tx,
+        graph_name,
+        index_name,
+        node_a.key(),
+        &crate::value::Tensor::from_f32_slice(&[1.0, 0.0, 0.0]),
+      )
+      .unwrap();
+    store
+      .upsert_vector(
+        &mut tx,
+        graph_name,
+        index_name,
+        node_b.key(),
+        &crate::value::Tensor::from_f32_slice(&[0.0, 1.0, 0.0]),
+      )
+      .unwrap();
+    tx.close().unwrap();
+
+    // Delete node_a and commit. No reload happens.
+    let mut tx = store.begin_write().unwrap();
+    store
+      .delete_nodes(
+        &mut tx,
+        graph_name,
+        crate::store::SelectNodeQuery::select_keys(vec![node_a.key()]),
+        true,
+      )
+      .unwrap();
+    tx.close().unwrap();
+
+    // After delete: node_a's rows are physically absent, node_b's remain.
+    let (adj_len, vec_len, key_len) = store
+      .test_hnsw_table_row_counts(graph_name, index_name)
+      .unwrap();
+    assert_eq!(
+      adj_len, 1,
+      "deleted node's adjacency rows must be physically removed, not tombstoned; \
+       only node_b's adjacency record remains"
+    );
+    assert_eq!(
+      vec_len, 1,
+      "deleted node's vector rows must be physically removed"
+    );
+    assert_eq!(
+      key_len, 1,
+      "deleted node's key records must be physically removed"
+    );
+
+    // Confirm search-level behavior excludes deleted node.
+    let mut tx = store.begin_read().unwrap();
+    let results = store
+      .vector_search(
+        &mut tx,
+        graph_name,
+        index_name,
+        &crate::value::Tensor::from_f32_slice(&[1.0, 0.0, 0.0]),
+        5,
+      )
+      .unwrap();
+    tx.close().unwrap();
+    assert!(
+      !results.iter().any(|r| r.node_id == node_a.key()),
+      "deleted node must not appear in search results"
+    );
+    assert!(
+      results.iter().any(|r| r.node_id == node_b.key()),
+      "surviving node must still be searchable"
+    );
+  }
+
+  #[test]
+  #[serial]
+  fn test_deleted_vector_stays_deleted_after_reopen_without_reconciliation()
+  {
+    // This is WI #5.1's generic reopen test, re-asserted here in redb-specific
+    // form so it can also check that no reload-time reconciliation was needed:
+    // row counts before close and after reopen must be identical. If a
+    // reconciliation pass is still running, it may coincidentally produce the
+    // same *search* result while doing unnecessary work -- this test catches
+    // that by comparing table state, not just search output.
+    let temp_file = crate::tests::create_tmp_file();
+    let path = temp_file.path();
+    let graph_name = "deleted_stays_deleted_reopen";
+    let index_name = "idx";
+
+    let (adj_before, vec_before, key_before) = {
+      let store = crate::store::redb::Store::open(path).unwrap();
+
+      let nodes: Vec<_> = (1u128..=3)
+        .map(|id| {
+          crate::graph::Node::new(
+            Some(graph_name.into()),
+            crate::graph::Key::new(id),
+            crate::graph::labels!("Item"),
+            crate::value::ValueMap::new(),
+          )
+        })
+        .collect();
+
+      let mut tx = store.begin_write().unwrap();
+      store.create_graph(&mut tx, graph_name, false).unwrap();
+      store
+        .create_vector_index(
+          &mut tx,
+          graph_name,
+          VectorIndexSpec {
+            name: index_name.into(),
+            dimension: 3,
+            metric: VectorMetric::Cosine,
+            ..Default::default()
+          },
+        )
+        .unwrap();
+      store
+        .create_nodes(&mut tx, graph_name, nodes.iter())
+        .unwrap();
+      for (node, v) in nodes
+        .iter()
+        .zip([[1.0f32, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]])
+      {
+        store
+          .upsert_vector(
+            &mut tx,
+            graph_name,
+            index_name,
+            node.key(),
+            &crate::value::Tensor::from_f32_slice(&v),
+          )
+          .unwrap();
+      }
+      tx.close().unwrap();
+
+      // Delete node 2 and commit.
+      let mut tx = store.begin_write().unwrap();
+      store
+        .delete_nodes(
+          &mut tx,
+          graph_name,
+          crate::store::SelectNodeQuery::select_keys(vec![nodes[1].key()]),
+          true,
+        )
+        .unwrap();
+      tx.close().unwrap();
+
+      store
+        .test_hnsw_table_row_counts(graph_name, index_name)
+        .unwrap()
+    }; // store dropped here
+
+    assert_eq!(
+      adj_before, 2,
+      "after delete: 2 live adjacency rows remain (deleted rows physically removed, not tombstoned)"
+    );
+
+    let store = crate::store::redb::Store::open(path).unwrap(); // reload runs here
+
+    let (adj_after, vec_after, key_after) = store
+      .test_hnsw_table_row_counts(graph_name, index_name)
+      .unwrap();
+    assert_eq!(
+      (adj_after, vec_after, key_after),
+      (adj_before, vec_before, key_before),
+      "reload must not add, remove, or otherwise touch persisted rows -- \
+       a reconciliation pass rewriting records would change these counts \
+       even if search output looked identical"
+    );
+
+    let mut tx = store.begin_read().unwrap();
+    let results = store
+      .vector_search(
+        &mut tx,
+        graph_name,
+        index_name,
+        &crate::value::Tensor::from_f32_slice(&[0.0, 1.0, 0.0]),
+        3,
+      )
+      .unwrap();
+    tx.close().unwrap();
+
+    assert!(
+      !results
+        .iter()
+        .any(|r| r.node_id == crate::graph::Key::new(2)),
+      "deleted node must not reappear after reopen"
+    );
+    assert_eq!(
+      results.len(),
+      2,
+      "exactly the 2 surviving nodes must be returned"
+    );
+  }
+
+  #[test]
+  #[serial]
+  fn test_repeated_delete_and_reopen_does_not_grow_persisted_table_size()
+  {
+    let temp_file = crate::tests::create_tmp_file();
+    let path = temp_file.path();
+    let graph_name = "no_leak_growth";
+    let index_name = "idx";
+
+    const N: usize = 20;
+
+    {
+      let store = crate::store::redb::Store::open(path).unwrap();
+      let nodes: Vec<_> = (1u128..=N as u128)
+        .map(|id| {
+          crate::graph::Node::new(
+            Some(graph_name.into()),
+            crate::graph::Key::new(id),
+            crate::graph::labels!("Item"),
+            crate::value::ValueMap::new(),
+          )
+        })
+        .collect();
+
+      let mut tx = store.begin_write().unwrap();
+      store.create_graph(&mut tx, graph_name, false).unwrap();
+      store
+        .create_vector_index(
+          &mut tx,
+          graph_name,
+          VectorIndexSpec {
+            name: index_name.into(),
+            dimension: 3,
+            metric: VectorMetric::Cosine,
+            ..Default::default()
+          },
+        )
+        .unwrap();
+      store
+        .create_nodes(&mut tx, graph_name, nodes.iter())
+        .unwrap();
+      for (i, node) in nodes.iter().enumerate()
+      {
+        let v = [(i as f32) / N as f32, 0.0, 1.0 - (i as f32) / N as f32];
+        store
+          .upsert_vector(
+            &mut tx,
+            graph_name,
+            index_name,
+            node.key(),
+            &crate::value::Tensor::from_f32_slice(&v),
+          )
+          .unwrap();
+      }
+      tx.close().unwrap();
+
+      // Delete half.
+      let mut tx = store.begin_write().unwrap();
+      let to_delete: Vec<_> = nodes.iter().take(N / 2).map(|n| n.key()).collect();
+      store
+        .delete_nodes(
+          &mut tx,
+          graph_name,
+          crate::store::SelectNodeQuery::select_keys(to_delete),
+          true,
+        )
+        .unwrap();
+      tx.close().unwrap();
+    }
+
+    // Reopen, then delete another quarter.
+    let (adj_after_first_round, _, _) = {
+      let store = crate::store::redb::Store::open(path).unwrap();
+      let remaining: Vec<u128> = ((N / 2 + 1) as u128..=N as u128).collect();
+
+      let mut tx = store.begin_write().unwrap();
+      let quarter = remaining.len() / 2;
+      let to_delete: Vec<_> = remaining
+        .iter()
+        .take(quarter)
+        .map(|&id| crate::graph::Key::new(id))
+        .collect();
+      store
+        .delete_nodes(
+          &mut tx,
+          graph_name,
+          crate::store::SelectNodeQuery::select_keys(to_delete),
+          true,
+        )
+        .unwrap();
+      tx.close().unwrap();
+
+      store
+        .test_hnsw_table_row_counts(graph_name, index_name)
+        .unwrap()
+    };
+
+    // Expected adjacency row count: N/2 rows after deleting N/2, then minus quarter
+    // more after the second delete. Final count: N/2 - (N/2)/2 = N/4 ≈ 5 rows.
+    // With physical deletion (no tombstones), deleted rows are immediately removed.
+    const EXPECTED_AFTER_SECOND_DELETE: usize = N / 2 / 2; // Quarter remains
+    assert_eq!(
+      adj_after_first_round, EXPECTED_AFTER_SECOND_DELETE,
+      "after deleting N/2 then reopen then delete quarter more, expect N/4 rows \
+       (physical deletion, no tombstones) -- growth beyond this would \
+       indicate reload duplicating records"
+    );
+
+    // Reopen again; row count must be stable (no growth from the reopen itself).
+    let store = crate::store::redb::Store::open(path).unwrap();
+    let (adj_final, _, _) = store
+      .test_hnsw_table_row_counts(graph_name, index_name)
+      .unwrap();
+    assert_eq!(
+      adj_final, adj_after_first_round,
+      "a second reopen with no intervening writes must not change row count"
+    );
+  }
+}

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

@@ -0,0 +1,166 @@
+use crate::store::{
+  self, Store, TransactionBoxable as _, sqlbase::SqlStore, sqlite::GetConnection,
+};
+
+mod single_open
+{
+  crate::vector_index_test_suite!(
+    setup = |_| {
+      let tmp = crate::tests::create_tmp_file();
+      let store = crate::store::sqlite::Store::open(tmp.path()).unwrap();
+      (tmp, store)
+    }
+  );
+}
+
+mod reopen
+{
+  crate::vector_index_reopen_suite!(
+    setup = |_| {
+      let tmp = crate::tests::create_tmp_file();
+      let path = tmp.path().to_path_buf();
+      let factory = move || crate::store::sqlite::Store::open(path.as_path()).unwrap();
+      (tmp, factory)
+    }
+  );
+}
+
+#[test]
+fn test_sqlite_vector_binary_roundtrip()
+{
+  let original: Vec<f32> = vec![1.5, -2.25, 3.75];
+
+  let blob: Vec<u8> = original.iter().flat_map(|f| f.to_le_bytes()).collect();
+
+  let decoded: Vec<f32> = blob
+    .chunks_exact(4)
+    .map(|b| f32::from_le_bytes([b[0], b[1], b[2], b[3]]))
+    .collect();
+
+  assert_eq!(original, decoded);
+}
+
+#[test]
+fn test_sqlite_vec_extension_available()
+{
+  let tmp = crate::tests::create_tmp_file();
+  let store = crate::store::sqlite::Store::open(tmp.path()).unwrap();
+
+  let tx = store.begin_write().unwrap();
+
+  let res: Result<String, _> = tx
+    .get_connection()
+    .query_row("SELECT vec_version()", [], |row| row.get(0));
+
+  match res
+  {
+    Ok(v) => println!("sqlite-vec loaded: {}", v),
+    Err(e) => panic!("NOT loaded: {:?}", e),
+  }
+
+  let res = tx
+    .get_connection()
+    .execute("CREATE VIRTUAL TABLE test_vec USING vec0(c float[3])", ());
+
+  assert!(res.is_ok(), "sqlite-vec extension not loaded");
+
+  tx.close().unwrap();
+}
+
+#[test]
+fn test_sqlite_vec_table_has_node_id_column()
+{
+  let tmp = crate::tests::create_tmp_file();
+  let store = crate::store::sqlite::Store::open(tmp.path()).unwrap();
+
+  let mut tx = store.begin_write().unwrap();
+
+  store.create_graph(&mut tx, "g", false).unwrap();
+  store
+    .create_vector_index(
+      &mut tx,
+      "g",
+      store::VectorIndexSpec {
+        name: "idx".into(),
+        dimension: 3,
+        metric: store::VectorMetric::Cosine,
+        ..Default::default()
+      },
+    )
+    .unwrap();
+
+  let conn = tx.get_connection();
+
+  let mut stmt = conn.prepare("PRAGMA table_info(vec_g_idx)").unwrap();
+  let cols: Vec<String> = stmt
+    .query_map([], |row| row.get::<_, String>(1))
+    .unwrap()
+    .map(|r| r.unwrap())
+    .collect();
+  drop(stmt);
+
+  assert!(
+    cols.contains(&"node_id".to_string()),
+    "vec table missing node_id column"
+  );
+
+  tx.close().unwrap();
+}
+
+#[test]
+fn test_sqlite_metadata_round_trip()
+{
+  let tmp = crate::tests::create_tmp_file();
+  let store = crate::store::sqlite::Store::open(tmp.path()).unwrap();
+
+  let mut tx = store.begin_write().unwrap();
+  for (name, metric) in [
+    ("idx_cos", store::VectorMetric::Cosine),
+    ("idx_l2", store::VectorMetric::L2),
+    ("idx_dot", store::VectorMetric::DotProduct),
+  ]
+  {
+    store
+      .create_vector_index(
+        &mut tx,
+        "default",
+        store::VectorIndexSpec {
+          name: name.to_string(),
+          label: Some("Item".to_string()),
+          property: Some("embedding".to_string()),
+          dimension: 3,
+          metric,
+          ..Default::default()
+        },
+      )
+      .unwrap();
+  }
+  tx.close().unwrap();
+
+  let mut tx = store.begin_read().unwrap();
+  let mut indices =
+    <crate::store::sqlite::Store as SqlStore>::get_vector_indices_for_property_impl(
+      &store,
+      &mut tx,
+      "default",
+      "Item",
+      "embedding",
+    )
+    .unwrap();
+  tx.close().unwrap();
+
+  indices.sort_by(|a, b| a.0.cmp(&b.0));
+  assert_eq!(indices.len(), 3);
+  assert_eq!(
+    indices[0],
+    ("idx_cos".to_string(), 3, store::VectorMetric::Cosine)
+  );
+  assert_eq!(
+    indices[1],
+    ("idx_dot".to_string(), 3, store::VectorMetric::DotProduct)
+  );
+  assert_eq!(
+    indices[2],
+    ("idx_l2".to_string(), 3, store::VectorMetric::L2)
+  );
+}