gqlite 1.5.0 → 1.7.0

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

@@ -0,0 +1,702 @@
+use db_index::hnsw::id::NodeId;
+use redb::{ReadableTable, Table, TableDefinition};
+
+use crate::{graph, prelude::*};
+
+/// Convert gqlitedb errors to hnsw_stable errors for trait bridge
+fn store_error(e: impl std::fmt::Display) -> db_index::hnsw::Error
+{
+  db_index::hnsw::Error::StoreError(e.to_string())
+}
+
+/// Simple metadata for tracking next_node_id and entry point within the dedicated meta table.
+/// This is a minimal version until the full HnswMetaBlob serialization is available.
+#[derive(serde::Serialize, serde::Deserialize, Clone)]
+pub(crate) struct SimpleMetaBlob
+{
+  pub next_node_id: u32,
+  pub entry_point: Option<u32>,
+  pub max_level: i32,
+}
+
+/// Manages the five table definitions for one HNSW index.
+/// Table names are computed from (graph_name, index_name) at construction and stored as String fields.
+pub(crate) struct HnswTableSet
+{
+  adj_table: String,
+  vec_table: String,
+  key_table: String,
+  key_rev_table: String,
+  meta_table: String,
+}
+
+impl HnswTableSet
+{
+  pub(crate) fn new(graph_name: &str, index_name: &str) -> Self
+  {
+    Self {
+      adj_table: format!("__{graph_name}__hnsw_{index_name}_adj"),
+      vec_table: format!("__{graph_name}__hnsw_{index_name}_vec"),
+      key_table: format!("__{graph_name}__hnsw_{index_name}_key"),
+      key_rev_table: format!("__{graph_name}__hnsw_{index_name}_rkey"),
+      meta_table: format!("__{graph_name}__hnsw_{index_name}_meta"),
+    }
+  }
+
+  /// Returns the table definition for adjacency layer data.
+  /// Uses Vec<u8> instead of &'static [u8] to allow arbitrary runtime byte slices
+  /// to be stored with proper lifetime semantics and ownership transfer into redb.
+  pub(crate) fn adj(&self) -> TableDefinition<'_, u32, Vec<u8>>
+  {
+    TableDefinition::new(&self.adj_table)
+  }
+
+  /// Returns the table definition for vector data.
+  /// Uses Vec<u8> for the same lifetime/ownership reasons as adj().
+  pub(crate) fn vec(&self) -> TableDefinition<'_, u32, Vec<u8>>
+  {
+    TableDefinition::new(&self.vec_table)
+  }
+
+  pub(crate) fn key(&self) -> TableDefinition<'_, u32, u128>
+  {
+    TableDefinition::new(&self.key_table)
+  }
+
+  pub(crate) fn key_rev(&self) -> TableDefinition<'_, u128, u32>
+  {
+    TableDefinition::new(&self.key_rev_table)
+  }
+
+  pub(crate) fn meta(&self) -> TableDefinition<'_, (), Vec<u8>>
+  {
+    TableDefinition::new(&self.meta_table)
+  }
+}
+
+/// Write adapter for HNSW graph operations.
+/// Owns five redb Table handles directly from a WriteTransaction.
+/// `GraphStoreWrite<graph::Key>` requires `&mut self` for write operations.
+pub(crate) struct RedbGraphStore<'txn>
+{
+  adj: Table<'txn, u32, Vec<u8>>,
+  key: Table<'txn, u32, u128>,
+  key_rev: Table<'txn, u128, u32>,
+  meta: Table<'txn, (), Vec<u8>>,
+}
+
+impl<'txn> RedbGraphStore<'txn>
+{
+  pub(crate) fn open(txn: &'txn super::WriteTransaction, tables: &HnswTableSet) -> Result<Self>
+  {
+    let adj = txn.write_transaction.open_table(tables.adj())?;
+    let key = txn.write_transaction.open_table(tables.key())?;
+    let key_rev = txn.write_transaction.open_table(tables.key_rev())?;
+    let meta = txn.write_transaction.open_table(tables.meta())?;
+
+    Ok(Self {
+      adj,
+      key,
+      key_rev,
+      meta,
+    })
+  }
+
+  fn read_meta(&self) -> Result<SimpleMetaBlob>
+  {
+    let bytes = self
+      .meta
+      .get(&())?
+      .map(|g| g.value().to_vec())
+      .ok_or_else(|| {
+        crate::error::Error::StoreError(crate::error::StoreError::InvalidFormat(
+          "meta row missing".into(),
+        ))
+      })?;
+    ciborium::from_reader(bytes.as_slice()).map_err(|e| crate::error::Error::Internal(e.into()))
+  }
+
+  pub(crate) fn write_meta(&mut self, meta: &SimpleMetaBlob) -> Result<()>
+  {
+    let mut bytes = Vec::new();
+    ciborium::into_writer(meta, &mut bytes).map_err(|e| crate::error::Error::Internal(e.into()))?;
+    self.meta.insert((), bytes)?;
+    Ok(())
+  }
+}
+
+impl<'txn> db_index::hnsw::graph_store::GraphStoreRead<graph::Key> for RedbGraphStore<'txn>
+{
+  type Error = db_index::hnsw::Error;
+
+  fn node_count(&self) -> std::result::Result<usize, db_index::hnsw::Error>
+  {
+    Ok(self.read_meta().map_err(store_error)?.next_node_id as usize)
+  }
+
+  fn entry_point(&self) -> std::result::Result<Option<(NodeId, i32)>, db_index::hnsw::Error>
+  {
+    let m = self.read_meta().map_err(store_error)?;
+    Ok(
+      m.entry_point
+        .map(|raw| (NodeId::from_u32(raw), m.max_level)),
+    )
+  }
+
+  fn contains(&self, node: NodeId) -> std::result::Result<bool, db_index::hnsw::Error>
+  {
+    Ok(self.adj.get(&node.as_u32()).map_err(store_error)?.is_some())
+  }
+
+  fn key_of(&self, node: NodeId) -> std::result::Result<Option<graph::Key>, db_index::hnsw::Error>
+  {
+    Ok(
+      self
+        .key
+        .get(&node.as_u32())
+        .map_err(store_error)?
+        .map(|g| graph::Key::new(g.value())),
+    )
+  }
+
+  fn node_of(&self, key: &graph::Key)
+  -> std::result::Result<Option<NodeId>, db_index::hnsw::Error>
+  {
+    Ok(
+      self
+        .key_rev
+        .get(&key.uuid())
+        .map_err(store_error)?
+        .map(|g| NodeId::from_u32(g.value())),
+    )
+  }
+
+  fn level(&self, node: NodeId) -> std::result::Result<i32, db_index::hnsw::Error>
+  {
+    let bytes = self
+      .adj
+      .get(&node.as_u32())
+      .map_err(store_error)?
+      .ok_or_else(|| store_error("level of absent node".to_string()))?;
+    Ok(bytes.value()[0] as i32)
+  }
+
+  fn neighbors(
+    &self,
+    node: NodeId,
+    level: usize,
+    out: &mut Vec<NodeId>,
+  ) -> std::result::Result<(), db_index::hnsw::Error>
+  {
+    out.clear();
+    let Some(bytes) = self.adj.get(&node.as_u32()).map_err(store_error)?
+    else
+    {
+      return Ok(());
+    };
+    let (_, layers) = db_index::hnsw::store::decode_adjacency_layers(bytes.value().as_slice())
+      .map_err(store_error)?;
+    if let Some(layer) = layers.get(level)
+    {
+      out.extend(layer.iter().map(|&id| NodeId::from_u32(id)));
+    }
+    Ok(())
+  }
+}
+
+impl<'txn> db_index::hnsw::graph_store::GraphStoreWrite<graph::Key> for RedbGraphStore<'txn>
+{
+  fn insert_node(
+    &mut self,
+    key: graph::Key,
+    level: i32,
+  ) -> std::result::Result<NodeId, db_index::hnsw::Error>
+  {
+    let mut meta = self.read_meta().map_err(store_error)?;
+    let id = NodeId::from_u32(meta.next_node_id);
+    meta.next_node_id += 1; // monotonic; the sole enforcement of never-reuse
+    self.write_meta(&meta).map_err(store_error)?;
+    self
+      .key
+      .insert(id.as_u32(), key.uuid())
+      .map_err(store_error)?;
+    self
+      .key_rev
+      .insert(key.uuid(), id.as_u32())
+      .map_err(store_error)?;
+    let empty_layers = vec![Vec::new(); (level as usize) + 1];
+    self
+      .adj
+      .insert(
+        id.as_u32(),
+        db_index::hnsw::store::encode_adjacency(level as u8, &empty_layers),
+      )
+      .map_err(store_error)?;
+    Ok(id)
+  }
+
+  fn set_neighbors(
+    &mut self,
+    node: NodeId,
+    level: usize,
+    nbrs: &[NodeId],
+  ) -> std::result::Result<(), db_index::hnsw::Error>
+  {
+    let cur = self
+      .adj
+      .get(&node.as_u32())
+      .map_err(store_error)?
+      .ok_or_else(|| store_error("set_neighbors on absent node"))?;
+    let (lvl, mut layers) = db_index::hnsw::store::decode_adjacency_layers(cur.value().as_slice())
+      .map_err(store_error)?;
+    drop(cur);
+    if layers.len() <= level
+    {
+      layers.resize(level + 1, Vec::new());
+    }
+    layers[level] = nbrs.iter().map(|n| n.as_u32()).collect();
+    self
+      .adj
+      .insert(
+        node.as_u32(),
+        db_index::hnsw::store::encode_adjacency(lvl, &layers),
+      )
+      .map_err(store_error)?;
+    Ok(())
+  }
+
+  fn set_entry_point(
+    &mut self,
+    ep: Option<(NodeId, i32)>,
+  ) -> std::result::Result<(), db_index::hnsw::Error>
+  {
+    let mut meta = self.read_meta().map_err(store_error)?;
+    meta.entry_point = ep.map(|(n, _)| n.as_u32());
+    meta.max_level = ep.map_or(-1, |(_, l)| l);
+    self.write_meta(&meta).map_err(store_error)
+  }
+
+  fn remove_node(&mut self, node: NodeId) -> std::result::Result<(), db_index::hnsw::Error>
+  {
+    if let Some(k) = self.key.remove(node.as_u32()).map_err(store_error)?
+    {
+      self.key_rev.remove(k.value()).map_err(store_error)?;
+    }
+    self.adj.remove(node.as_u32()).map_err(store_error)?;
+    Ok(()) // next_node_id in meta untouched
+  }
+}
+
+/// Write adapter for HNSW vector operations.
+/// Uses Mutex for interior mutability (required by VectorStoreMut trait taking &self).
+/// Safe because write transactions are exclusive, so contention never occurs.
+pub(crate) struct RedbVectorStore<'txn>
+{
+  vec: std::sync::Mutex<Table<'txn, u32, Vec<u8>>>,
+  dim: usize,
+  encoding: db_index::hnsw::store::VectorEncoding,
+}
+
+impl<'txn> RedbVectorStore<'txn>
+{
+  pub(crate) fn open(
+    txn: &'txn super::WriteTransaction,
+    tables: &HnswTableSet,
+    dim: usize,
+    encoding: db_index::hnsw::store::VectorEncoding,
+  ) -> Result<Self>
+  {
+    let vec = txn.write_transaction.open_table(tables.vec())?;
+    Ok(Self {
+      vec: std::sync::Mutex::new(vec),
+      dim,
+      encoding,
+    })
+  }
+
+  pub(crate) fn delete(&self, id: NodeId) -> Result<()>
+  {
+    let id_u32 = id.as_u32();
+    let mut table = self.vec.lock().map_err(|_| {
+      crate::error::Error::Internal(crate::error::InternalError::Unimplemented(
+        "failed to acquire table lock for vector deletion",
+      ))
+    })?;
+    table.remove(id_u32)?;
+    Ok(())
+  }
+}
+
+impl<'txn> db_index::hnsw::vectors::VectorStore for RedbVectorStore<'txn>
+{
+  type Family = db_index::hnsw::vector::Dense<f32>;
+  type Vector<'a>
+    = db_index::hnsw::vectors::ArcVector<f32>
+  where
+    Self: 'a;
+
+  fn dim(&self) -> usize
+  {
+    self.dim
+  }
+
+  fn vector(&self, id: NodeId) -> Option<Self::Vector<'_>>
+  {
+    let id_u32 = id.as_u32();
+    let table = self.vec.lock().ok()?;
+    let bytes = table.get(&id_u32).ok()??.value().to_vec();
+    let floats = db_index::hnsw::store::decode_vector(&self.encoding, &bytes, self.dim)
+      .map_err(|_| ())
+      .ok()?;
+    Some(db_index::hnsw::vectors::ArcVector::new(
+      floats.into_boxed_slice(),
+    ))
+  }
+}
+
+impl<'txn> db_index::hnsw::vectors::VectorStoreMut for RedbVectorStore<'txn>
+{
+  fn set(
+    &self,
+    id: NodeId,
+    vector: <Self::Family as db_index::hnsw::vector::VectorFamily>::Ref<'_>,
+  ) -> db_index::hnsw::error::Result<()>
+  {
+    let bytes = db_index::hnsw::store::encode_vector(&self.encoding, vector)?;
+    let id_u32 = id.as_u32();
+    let mut table = self
+      .vec
+      .lock()
+      .map_err(|_| db_index::hnsw::Error::StoreError("failed to acquire table lock".into()))?;
+    table.insert(id_u32, bytes).map_err(store_error)?;
+    Ok(())
+  }
+}
+
+/// Read-only HNSW graph store backed by redb read-only tables.
+///
+/// Implements `GraphStoreRead<graph::Key>` for loading HNSW graph structure from disk.
+pub(crate) struct RedbGraphStoreRead<'txn>
+{
+  adj: redb::ReadOnlyTable<u32, Vec<u8>>,
+  key: redb::ReadOnlyTable<u32, u128>,
+  key_rev: redb::ReadOnlyTable<u128, u32>,
+  meta: redb::ReadOnlyTable<(), Vec<u8>>,
+  _marker: std::marker::PhantomData<&'txn ()>,
+}
+
+impl<'txn> RedbGraphStoreRead<'txn>
+{
+  /// Opens read-only tables for an HNSW index.
+  ///
+  /// Returns `Ok(None)` if the adjacency table does not exist,
+  /// indicating the index has not yet been created (e.g., new database).
+  pub(crate) fn open(
+    txn: &'txn redb::ReadTransaction,
+    tables: &HnswTableSet,
+  ) -> Result<Option<Self>>
+  {
+    let adj = match txn.open_table(tables.adj())
+    {
+      Ok(t) => t,
+      Err(redb::TableError::TableDoesNotExist(_)) => return Ok(None),
+      Err(e) => return Err(e.into()),
+    };
+
+    Ok(Some(Self {
+      adj,
+      key: txn.open_table(tables.key())?,
+      key_rev: txn.open_table(tables.key_rev())?,
+      meta: txn.open_table(tables.meta())?,
+      _marker: std::marker::PhantomData,
+    }))
+  }
+
+  fn read_meta(&self) -> Result<SimpleMetaBlob>
+  {
+    let bytes = self
+      .meta
+      .get(&())?
+      .map(|g| g.value().to_vec())
+      .ok_or_else(|| {
+        crate::error::Error::StoreError(crate::error::StoreError::InvalidFormat(
+          "meta row missing".into(),
+        ))
+      })?;
+    ciborium::from_reader(bytes.as_slice()).map_err(|e| crate::error::Error::Internal(e.into()))
+  }
+}
+
+impl<'txn> db_index::hnsw::graph_store::GraphStoreRead<graph::Key> for RedbGraphStoreRead<'txn>
+{
+  type Error = db_index::hnsw::Error;
+
+  fn node_count(&self) -> std::result::Result<usize, db_index::hnsw::Error>
+  {
+    let count = self.read_meta().map_err(store_error)?.next_node_id as usize;
+    Ok(count)
+  }
+
+  fn entry_point(&self) -> std::result::Result<Option<(NodeId, i32)>, db_index::hnsw::Error>
+  {
+    let m = self.read_meta().map_err(store_error)?;
+    Ok(
+      m.entry_point
+        .map(|raw| (NodeId::from_u32(raw), m.max_level)),
+    )
+  }
+
+  fn contains(&self, node: NodeId) -> std::result::Result<bool, db_index::hnsw::Error>
+  {
+    Ok(self.adj.get(&node.as_u32()).map_err(store_error)?.is_some())
+  }
+
+  fn key_of(&self, node: NodeId) -> std::result::Result<Option<graph::Key>, db_index::hnsw::Error>
+  {
+    Ok(
+      self
+        .key
+        .get(&node.as_u32())
+        .map_err(store_error)?
+        .map(|g| graph::Key::new(g.value())),
+    )
+  }
+
+  fn node_of(&self, key: &graph::Key)
+  -> std::result::Result<Option<NodeId>, db_index::hnsw::Error>
+  {
+    Ok(
+      self
+        .key_rev
+        .get(&key.uuid())
+        .map_err(store_error)?
+        .map(|g| NodeId::from_u32(g.value())),
+    )
+  }
+
+  fn level(&self, node: NodeId) -> std::result::Result<i32, db_index::hnsw::Error>
+  {
+    let bytes = self
+      .adj
+      .get(&node.as_u32())
+      .map_err(store_error)?
+      .ok_or_else(|| store_error("level of absent node"))?;
+    Ok(bytes.value()[0] as i32)
+  }
+
+  fn neighbors(
+    &self,
+    node: NodeId,
+    level: usize,
+    out: &mut Vec<NodeId>,
+  ) -> std::result::Result<(), db_index::hnsw::Error>
+  {
+    out.clear();
+    let Some(bytes) = self.adj.get(&node.as_u32()).map_err(store_error)?
+    else
+    {
+      return Ok(());
+    };
+    let (_, layers) = db_index::hnsw::store::decode_adjacency_layers(bytes.value().as_slice())
+      .map_err(store_error)?;
+    if let Some(layer) = layers.get(level)
+    {
+      out.extend(layer.iter().map(|&id| NodeId::from_u32(id)));
+    }
+    Ok(())
+  }
+}
+
+/// Read-only HNSW vector store backed by redb read-only tables.
+///
+/// Implements `VectorStore` for loading HNSW vectors from disk.
+pub(crate) struct RedbVectorStoreRead<'txn>
+{
+  vec: redb::ReadOnlyTable<u32, Vec<u8>>,
+  dim: usize,
+  encoding: db_index::hnsw::store::VectorEncoding,
+  _marker: std::marker::PhantomData<&'txn ()>,
+}
+
+impl<'txn> RedbVectorStoreRead<'txn>
+{
+  /// Opens read-only tables for an HNSW vector index.
+  pub(crate) fn open(
+    txn: &'txn redb::ReadTransaction,
+    tables: &HnswTableSet,
+    dim: usize,
+    encoding: db_index::hnsw::store::VectorEncoding,
+  ) -> Result<Option<Self>>
+  {
+    let vec = match txn.open_table(tables.vec())
+    {
+      Ok(t) => t,
+      Err(redb::TableError::TableDoesNotExist(_)) => return Ok(None),
+      Err(e) => return Err(e.into()),
+    };
+
+    Ok(Some(Self {
+      vec,
+      dim,
+      encoding,
+      _marker: std::marker::PhantomData,
+    }))
+  }
+}
+
+impl<'txn> db_index::hnsw::vectors::VectorStore for RedbVectorStoreRead<'txn>
+{
+  type Family = db_index::hnsw::vector::Dense<f32>;
+  type Vector<'a>
+    = db_index::hnsw::vectors::ArcVector<f32>
+  where
+    Self: 'a;
+
+  fn dim(&self) -> usize
+  {
+    self.dim
+  }
+
+  fn vector(&self, id: NodeId) -> Option<Self::Vector<'_>>
+  {
+    let id_u32 = id.as_u32();
+    let bytes = self.vec.get(&id_u32).ok()??.value().to_vec();
+    let floats = db_index::hnsw::store::decode_vector(&self.encoding, &bytes, self.dim)
+      .map_err(|_| ())
+      .ok()?;
+    Some(db_index::hnsw::vectors::ArcVector::new(
+      floats.into_boxed_slice(),
+    ))
+  }
+}
+
+#[cfg(test)]
+mod tests
+{
+  use super::*;
+
+  #[test]
+  fn test_hnsw_table_set_construction_and_names()
+  {
+    let hnsw_set = HnswTableSet::new("mygraph", "embedding");
+
+    assert_eq!(hnsw_set.adj_table, "__mygraph__hnsw_embedding_adj");
+    assert_eq!(hnsw_set.vec_table, "__mygraph__hnsw_embedding_vec");
+    assert_eq!(hnsw_set.key_table, "__mygraph__hnsw_embedding_key");
+    assert_eq!(hnsw_set.key_rev_table, "__mygraph__hnsw_embedding_rkey");
+    assert_eq!(hnsw_set.meta_table, "__mygraph__hnsw_embedding_meta");
+  }
+
+  #[test]
+  fn test_hnsw_table_set_multiple_indices()
+  {
+    let index1 = HnswTableSet::new("graph1", "idx1");
+    let index2 = HnswTableSet::new("graph1", "idx2");
+    let index3 = HnswTableSet::new("graph2", "idx1");
+
+    assert_eq!(index1.adj_table, "__graph1__hnsw_idx1_adj");
+    assert_eq!(index2.adj_table, "__graph1__hnsw_idx2_adj");
+    assert_eq!(index3.adj_table, "__graph2__hnsw_idx1_adj");
+
+    assert_eq!(index1.key_rev_table, "__graph1__hnsw_idx1_rkey");
+    assert_eq!(index2.key_rev_table, "__graph1__hnsw_idx2_rkey");
+    assert_eq!(index3.key_rev_table, "__graph2__hnsw_idx1_rkey");
+  }
+}
+
+#[cfg(test)]
+mod graph_store_tests
+{
+  use super::*;
+  use crate::graph;
+  use db_index::hnsw::graph_store::{GraphStoreRead, GraphStoreWrite};
+  use db_index::hnsw::id::NodeId;
+  use redb::ReadableDatabase;
+
+  fn create_test_db() -> (redb::Database, ccutils::temporary::TemporaryFile)
+  {
+    let db_path = crate::tests::create_tmp_file();
+    let db = redb::Database::create(db_path.path()).expect("Failed to create test database");
+    (db, db_path)
+  }
+
+  #[test]
+  fn test_graph_store_metadata_roundtrip()
+  {
+    let (db, _db_path) = create_test_db();
+
+    // First transaction: write data
+    {
+      let write_tx = db.begin_write().expect("Failed to begin write transaction");
+      let txn = super::super::WriteTransaction {
+        write_transaction: write_tx,
+      };
+      let tables = HnswTableSet::new("g", "idx_meta_roundtrip");
+      let mut store = RedbGraphStore::open(&txn, &tables).unwrap();
+      // Initialize metadata
+      let meta = SimpleMetaBlob {
+        next_node_id: 0,
+        entry_point: None,
+        max_level: -1,
+      };
+      store.write_meta(&meta).unwrap();
+      let node = store.insert_node(graph::Key::new(1), 2).unwrap();
+      store.set_entry_point(Some((node, 2))).unwrap();
+      drop(store);
+      // Commit the transaction
+      txn.write_transaction.commit().unwrap();
+    }
+
+    // Use a read transaction to verify data
+    {
+      let read_tx = db.begin_read().expect("Failed to begin read transaction");
+      let tables = HnswTableSet::new("g", "idx_meta_roundtrip");
+      let store = RedbGraphStoreRead::open(&read_tx, &tables)
+        .expect("Failed to open store read")
+        .expect("Store does not exist");
+      assert_eq!(store.entry_point().unwrap(), Some((NodeId::from_u32(0), 2)));
+    }
+  }
+
+  #[test]
+  fn test_key_rev_bidirectional_mapping()
+  {
+    let (db, _db_path) = create_test_db();
+
+    // First transaction: write keys
+    {
+      let write_tx = db.begin_write().expect("Failed to begin write transaction");
+      let txn = super::super::WriteTransaction {
+        write_transaction: write_tx,
+      };
+      let tables = HnswTableSet::new("g", "idx_key_rev");
+      let mut store = RedbGraphStore::open(&txn, &tables).unwrap();
+      // Initialize metadata
+      let meta = SimpleMetaBlob {
+        next_node_id: 0,
+        entry_point: None,
+        max_level: -1,
+      };
+      store.write_meta(&meta).unwrap();
+      let key = graph::Key::new(999u128);
+      let node_id = store.insert_node(key, 0).unwrap();
+      assert_eq!(store.key_of(node_id).unwrap(), Some(key));
+      assert_eq!(store.node_of(&key).unwrap(), Some(node_id));
+      drop(store);
+      // Commit the transaction
+      txn.write_transaction.commit().unwrap();
+    }
+
+    // Use a read transaction to verify bidirectional mapping
+    {
+      let read_tx = db.begin_read().expect("Failed to begin read transaction");
+      let tables = HnswTableSet::new("g", "idx_key_rev");
+      let store = RedbGraphStoreRead::open(&read_tx, &tables)
+        .expect("Failed to open store read")
+        .expect("Store does not exist");
+      let key = graph::Key::new(999u128);
+      assert_eq!(store.node_of(&key).unwrap(), Some(NodeId::from_u32(0)));
+      assert_eq!(store.key_of(NodeId::from_u32(0)).unwrap(), Some(key));
+    }
+  }
+}