gqlite 1.2.2 → 1.3.0

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/store/redb.rs

@@ -1,5 +1,5 @@
 use ccutils::sync::ArcRwLock;
-use redb::{ReadableTable, ReadableTableMetadata};
+use redb::{DatabaseError, ReadableDatabase as _, ReadableTable, ReadableTableMetadata as _};
 use serde::{Deserialize, Serialize};
 use std::{cell::RefCell, collections::HashMap, rc::Rc, sync::Arc};
 
@@ -16,9 +16,9 @@ use crate::{prelude::*, store::TransactionBoxable};
 #[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
 struct PersistentEdge
 {
-  pub key: graph::Key,
-  pub source: graph::Key,
-  pub destination: graph::Key,
+  pub key: PersistentKey,
+  pub source: PersistentKey,
+  pub destination: PersistentKey,
   pub labels: Vec<String>,
   pub properties: value::ValueMap,
 }
@@ -51,23 +51,54 @@ impl redb::Value for PersistentEdge
   }
 }
 
-impl redb::Value for graph::Node
+#[derive(Debug)]
+enum PersistentNode<'a>
 {
-  type AsBytes<'a> = Vec<u8>;
-  type SelfType<'a> = graph::Node;
+  Reference(&'a graph::Node),
+  Value(graph::Node),
+}
+
+impl<'a> From<PersistentNode<'a>> for graph::Node
+{
+  fn from(value: PersistentNode<'a>) -> Self
+  {
+    match value
+    {
+      PersistentNode::Reference(refe) => refe.to_owned(),
+      PersistentNode::Value(val) => val,
+    }
+  }
+}
+
+// ccutils::alias!(PersistentNode, graph::Node, derive: Debug, Deserialize, Serialize, Clone);
+
+impl<'c> redb::Value for PersistentNode<'c>
+{
+  type AsBytes<'a>
+    = Vec<u8>
+  where
+    Self: 'a;
+  type SelfType<'a>
+    = PersistentNode<'a>
+  where
+    Self: 'a;
   fn as_bytes<'a, 'b: 'a>(value: &'a Self::SelfType<'b>) -> Self::AsBytes<'a>
   where
     Self: 'b,
   {
     let mut data = Vec::<u8>::new();
-    ciborium::into_writer(value, &mut data).unwrap(); // This unwrap should not happen, unless there is a bug
+    match value
+    {
+      PersistentNode::Reference(refe) => ciborium::into_writer(refe, &mut data).unwrap(), // This unwrap should not happen, unless there is a bug
+      PersistentNode::Value(refe) => ciborium::into_writer(&refe, &mut data).unwrap(), // This unwrap should not happen, unless there is a bug
+    }
     data
   }
   fn from_bytes<'a>(data: &'a [u8]) -> Self::SelfType<'a>
   where
     Self: 'a,
   {
-    ciborium::from_reader(data).unwrap() // This unwrap should not happen, unless there is a bug
+    PersistentNode::Value(ciborium::from_reader(data).unwrap()) // This unwrap should not happen, unless there is a bug
   }
   fn fixed_width() -> Option<usize>
   {
@@ -79,15 +110,25 @@ impl redb::Value for graph::Node
   }
 }
 
-impl redb::Value for graph::Key
+ccutils::alias!(PersistentKey, graph::Key, derive: Debug, Deserialize, Serialize, PartialEq, Clone);
+
+impl PersistentKey
+{
+  fn to_owned_key(&self) -> graph::Key
+  {
+    *self.clone()
+  }
+}
+
+impl redb::Value for PersistentKey
 {
   type AsBytes<'a> = <u128 as redb::Value>::AsBytes<'a>;
-  type SelfType<'a> = graph::Key;
+  type SelfType<'a> = PersistentKey;
   fn as_bytes<'a, 'b: 'a>(value: &'a Self::SelfType<'b>) -> Self::AsBytes<'a>
   where
     Self: 'b,
   {
-    u128::as_bytes(&value.uuid)
+    u128::as_bytes(&value.uuid())
   }
   fn fixed_width() -> Option<usize>
   {
@@ -97,9 +138,7 @@ impl redb::Value for graph::Key
   where
     Self: 'a,
   {
-    graph::Key {
-      uuid: u128::from_bytes(data),
-    }
+    PersistentKey(graph::Key::new(u128::from_bytes(data)))
   }
   fn type_name() -> redb::TypeName
   {
@@ -107,7 +146,7 @@ impl redb::Value for graph::Key
   }
 }
 
-impl redb::Key for graph::Key
+impl redb::Key for PersistentKey
 {
   fn compare(data1: &[u8], data2: &[u8]) -> std::cmp::Ordering
   {
@@ -147,10 +186,10 @@ impl EdgeIdResult
       Some(v) => v,
       None => match self.source_id
       {
-        Some(v) => self.edge_data.destination == v,
+        Some(v) => *self.edge_data.destination == v,
         None => match self.destination_id
         {
-          Some(v) => self.edge_data.source == v,
+          Some(v) => *self.edge_data.source == v,
           None => panic!("is_reversed"),
         },
       },
@@ -164,21 +203,6 @@ impl EdgeIdResult
 //   | | (_| | |_) | |  __/
 //   |_|\__,_|_.__/|_|\___|
 
-trait NodeTableExtension
-{
-  fn get_node(&self, key: graph::Key) -> Result<graph::Node>;
-}
-
-impl<'txn> NodeTableExtension for redb::Table<'txn, graph::Key, &[u8]>
-{
-  fn get_node(&self, key: graph::Key) -> Result<graph::Node>
-  {
-    let v = self.get_required(key, || InternalError::UnknownNode)?;
-    let c = ciborium::from_reader::<graph::Node, &[u8]>(&mut v.value())?;
-    Ok::<graph::Node, crate::prelude::ErrorType>(c)
-  }
-}
-
 trait TableExtension<K, V>
 where
   K: redb::Key + 'static,
@@ -188,10 +212,10 @@ where
     &self,
     key: impl std::borrow::Borrow<K::SelfType<'a>>,
     f: impl FnOnce() -> TError,
-  ) -> Result<redb::AccessGuard<V>>;
+  ) -> Result<redb::AccessGuard<'_, V>>;
 }
 
-impl<'txn, K, V, T> TableExtension<K, V> for T
+impl<K, V, T> TableExtension<K, V> for T
 where
   T: ReadableTable<K, V>,
   K: redb::Key + 'static,
@@ -201,7 +225,7 @@ where
     &self,
     key: impl std::borrow::Borrow<K::SelfType<'a>>,
     f: impl FnOnce() -> TError,
-  ) -> Result<redb::AccessGuard<V>>
+  ) -> Result<redb::AccessGuard<'_, V>>
   {
     self.get(key)?.ok_or_else(|| f().into())
   }
@@ -217,6 +241,7 @@ where
 #[derive(Debug)]
 struct GraphInfo
 {
+  #[allow(dead_code)]
   name: String,
   nodes_table: String,
   edges_table: String,
@@ -242,23 +267,27 @@ impl GraphInfo
       edges_destination_index,
     }
   }
-  fn nodes_table_definition<'a>(&'a self) -> redb::TableDefinition<'a, graph::Key, graph::Node>
+  fn nodes_table_definition<'a, 'b>(
+    &'a self,
+  ) -> redb::TableDefinition<'a, PersistentKey, PersistentNode<'b>>
   {
     redb::TableDefinition::new(&self.nodes_table)
   }
-  fn edges_table_definition<'a>(&'a self) -> redb::TableDefinition<'a, graph::Key, PersistentEdge>
+  fn edges_table_definition<'a>(
+    &'a self,
+  ) -> redb::TableDefinition<'a, PersistentKey, PersistentEdge>
   {
     redb::TableDefinition::new(&self.edges_table)
   }
   fn edges_source_index_definition<'a>(
     &'a self,
-  ) -> redb::TableDefinition<'a, graph::Key, Vec<graph::Key>>
+  ) -> redb::TableDefinition<'a, PersistentKey, Vec<PersistentKey>>
   {
     redb::TableDefinition::new(&self.edges_source_index)
   }
   fn edges_destination_index_definition<'a>(
     &'a self,
-  ) -> redb::TableDefinition<'a, graph::Key, Vec<graph::Key>>
+  ) -> redb::TableDefinition<'a, PersistentKey, Vec<PersistentKey>>
   {
     redb::TableDefinition::new(&self.edges_destination_index)
   }
@@ -314,19 +343,62 @@ type TransactionBox = store::TransactionBox<redb::ReadTransaction, redb::WriteTr
 impl Store
 {
   /// Crate a new store, with a default graph
-  pub(crate) fn new<P: AsRef<std::path::Path>>(path: P) -> Result<Store>
+  pub(crate) fn open<P: AsRef<std::path::Path>>(path: P) -> Result<Store>
   {
+    let redb_store = redb::Database::create(path.as_ref());
+    let redb_store = match redb_store
+    {
+      Ok(redb_store) => redb_store,
+      Err(e) => match e
+      {
+        DatabaseError::UpgradeRequired(v) =>
+        {
+          if v == 2
+          {
+            std::fs::copy(path.as_ref(), path.as_ref().with_extension("redb2.bak"))
+              .map_err(InternalError::IOError)?;
+            redb2::Database::create(path.as_ref())?.upgrade()?;
+            redb::Database::create(path.as_ref())?
+          }
+          else
+          {
+            Err(StoreError::InvalidFormat(format!(
+              "Unsupported redb version {}.",
+              v
+            )))?
+          }
+        }
+        o => Err(o)?,
+      },
+    };
     let s = Self {
-      redb_store: redb::Database::create(path.as_ref())?,
+      redb_store,
       graphs: Default::default(),
     };
+    s.initialise()?;
+    Ok(s)
+  }
+  /// Crate a new store, with a default graph, in memory
+  pub(crate) fn in_memory() -> Result<Store>
+  {
+    let s = Self {
+      redb_store: redb::Database::builder()
+        .create_with_backend(redb::backends::InMemoryBackend::new())?,
+      graphs: Default::default(),
+    };
+    s.initialise()?;
+    Ok(s)
+  }
+  fn initialise(&self) -> Result<()>
+  {
     use crate::store::Store;
-    let mut tx = s.begin_write()?;
-    s.create_graph(&mut tx, &"default".to_string(), true)?;
-    s.set_metadata_value(&mut tx, "version", &consts::GQLITE_VERSION)?;
+    let mut tx = self.begin_write()?;
+    self.create_graph(&mut tx, "default", true)?;
+    self.set_metadata_value(&mut tx, "version", &consts::GQLITE_VERSION)?;
     tx.close()?;
-    Ok(s)
+    Ok(())
   }
+  #[allow(dead_code)]
   fn get_metadata_from_table<TTable, TValue>(
     &self,
     table: TTable,
@@ -339,9 +411,10 @@ impl Store
     let key = key.into();
     let value = table
       .get(&key)?
-      .ok_or_else(|| InternalError::MissingMetadata { key: key })?;
+      .ok_or_else(|| InternalError::MissingMetadata { key })?;
     Ok(ciborium::from_reader(value.value().as_slice())?)
   }
+  #[allow(dead_code)]
   fn get_metadata_value<T: for<'a> Deserialize<'a>>(
     &self,
     transaction: &mut TransactionBox,
@@ -415,8 +488,9 @@ impl Store
     metadata_table.insert(&key, data)?;
     Ok(())
   }
-  fn get_graph_info(&self, graph_name: &String) -> Result<Arc<GraphInfo>>
+  fn get_graph_info(&self, graph_name: impl AsRef<str>) -> Result<Arc<GraphInfo>>
   {
+    let graph_name = graph_name.as_ref();
     let graphs = self.graphs.read()?;
     let graph_info = graphs.get(graph_name);
     match graph_info
@@ -425,7 +499,7 @@ impl Store
       None =>
       {
         drop(graphs);
-        let graph_info = Arc::new(GraphInfo::new(graph_name));
+        let graph_info = Arc::new(GraphInfo::new(graph_name.to_owned()));
         self
           .graphs
           .write()?
@@ -434,31 +508,32 @@ impl Store
       }
     }
   }
-  fn select_nodes_from_table<'txn, T>(
+  fn select_nodes_from_table<T>(
     &self,
-    nodes_table: &'txn T,
-    query: super::SelectNodeQuery,
+    nodes_table: &T,
+    query: &super::SelectNodeQuery,
   ) -> Result<Vec<crate::graph::Node>>
   where
-    T: ReadableTable<graph::Key, graph::Node>,
+    T: ReadableTable<PersistentKey, PersistentNode<'static>>,
   {
-    let r = match query.keys
+    let r = match &query.keys
     {
-      Some(keys) => Box::new(keys.into_iter().map(|key| {
+      Some(keys) => Box::new(keys.iter().map(|key| {
         Ok(
           nodes_table
-            .get_required(key, || InternalError::UnknownNode)?
-            .value(),
+            .get_required(PersistentKey(key.to_owned()), || InternalError::UnknownNode)?
+            .value()
+            .into(),
         )
       })) as Box<dyn Iterator<Item = Result<graph::Node>>>,
       None => Box::new({
-        nodes_table.range::<graph::Key>(..)?.into_iter().map(|r| {
+        nodes_table.range::<PersistentKey>(..)?.map(|r| {
           let (_, v) = r?;
-          Ok(v.value())
+          Ok(v.value().into())
         })
       }) as Box<dyn Iterator<Item = Result<graph::Node>>>,
     };
-    let r = match query.labels
+    let r = match &query.labels
     {
       Some(labels) => Box::new(r.filter(move |n| match n
       {
@@ -466,7 +541,7 @@ impl Store
         {
           for l in labels.iter()
           {
-            if !n.labels.contains(l)
+            if !n.labels().contains(l)
             {
               return false;
             }
@@ -477,7 +552,7 @@ impl Store
       })) as Box<dyn Iterator<Item = Result<crate::graph::Node>>>,
       None => Box::new(r) as Box<dyn Iterator<Item = Result<crate::graph::Node>>>,
     };
-    let r = match query.properties
+    let r = match &query.properties
     {
       Some(properties) => Box::new(r.filter(move |n| match n
       {
@@ -485,7 +560,7 @@ impl Store
         {
           for (k, v) in properties.iter()
           {
-            match n.properties.get(k)
+            match n.properties().get(k)
             {
               Some(val) =>
               {
@@ -519,9 +594,9 @@ impl Store
     edges_destination_index: Rc<RefCell<TEdgesIndex>>,
   ) -> Result<Vec<super::EdgeResult>>
   where
-    TEdges: ReadableTable<graph::Key, PersistentEdge>,
-    TNodes: ReadableTable<graph::Key, graph::Node>,
-    TEdgesIndex: ReadableTable<graph::Key, Vec<graph::Key>>,
+    TEdges: ReadableTable<PersistentKey, PersistentEdge>,
+    TNodes: ReadableTable<PersistentKey, PersistentNode<'static>>,
+    TEdgesIndex: ReadableTable<PersistentKey, Vec<PersistentKey>>,
   {
     let edges_uuid_indices = match directivity
     {
@@ -539,12 +614,11 @@ impl Store
     {
       Some(keys) =>
       {
-        for key in keys.into_iter()
+        for key in keys.iter()
         {
           edges_raw.push(EdgeIdResult::new(
             edges_table
-              .get(key)?
-              .ok_or_else(|| InternalError::UnknownNode)?
+              .get_required(PersistentKey(key.to_owned()), || InternalError::UnknownNode)?
               .value(),
             Some(false),
             None,
@@ -557,8 +631,7 @@ impl Store
         if query.source.is_select_all() && query.destination.is_select_all()
         {
           edges_raw = edges_table
-            .range::<graph::Key>(..)?
-            .into_iter()
+            .range::<PersistentKey>(..)?
             .map(|r| {
               let (_, v) = r?;
               Ok(EdgeIdResult::new(v.value(), Some(false), None, None))
@@ -572,33 +645,36 @@ impl Store
           {
             if !query.destination.is_select_all() && !query.source.is_select_all()
             {
-              let dest_it =
-                self.select_nodes_from_table(&nodes_table, query.destination.clone())?;
+              let dest_it = self.select_nodes_from_table(&nodes_table, &query.destination)?;
               let dest_it: Vec<graph::Key> = dest_it
                 .into_iter()
                 .map(|n| {
                   edges_destination_uuid_index
+                    .as_ref()
                     .borrow()
-                    .get_required(n.key, || InternalError::UnknownNode)
-                    .map(|x| x.value())
+                    .get_required(PersistentKey(n.key()), || InternalError::UnknownNode)
+                    .map(|x| -> Vec<graph::Key> {
+                      x.value().into_iter().map(|x| x.into()).collect()
+                    })
                 })
                 .collect::<Result<Vec<_>>>()?
                 .into_iter()
                 .flatten()
                 .collect();
-              let nodes = self.select_nodes_from_table(&nodes_table, query.source.clone())?;
+              let nodes = self.select_nodes_from_table(&nodes_table, &query.source)?;
               for n in nodes.iter()
               {
-                let nkey = n.key;
+                let nkey = n.key();
                 for k in edges_source_uuid_index
+                  .as_ref()
                   .borrow()
-                  .get_required(nkey, || InternalError::UnknownNode)?
+                  .get_required(PersistentKey(nkey), || InternalError::UnknownNode)?
                   .value()
                   .iter()
                 {
                   if dest_it.contains(k)
                   {
-                    let uniq_k = (k.to_owned(), Some(nkey), None);
+                    let uniq_k: (graph::Key, _, _) = ((**k), Some(nkey), None);
                     if !edge_ids.contains(&uniq_k)
                     {
                       edges_raw.push(EdgeIdResult::new(
@@ -617,18 +693,19 @@ impl Store
             }
             else if !query.source.is_select_all()
             {
-              let nodes = self.select_nodes_from_table(&nodes_table, query.source.clone())?;
+              let nodes = self.select_nodes_from_table(&nodes_table, &query.source)?;
 
               for n in nodes.into_iter()
               {
-                let nkey = n.key;
+                let nkey = n.key();
                 for k in edges_source_uuid_index
+                  .as_ref()
                   .borrow()
-                  .get_required(nkey, || InternalError::UnknownNode)?
+                  .get_required(PersistentKey(nkey), || InternalError::UnknownNode)?
                   .value()
                   .iter()
                 {
-                  let uniq_k = (k.to_owned(), Some(nkey), None);
+                  let uniq_k = (k.to_owned_key(), Some(nkey), None);
                   if !edge_ids.contains(&uniq_k)
                   {
                     edges_raw.push(EdgeIdResult::new(
@@ -646,17 +723,18 @@ impl Store
             }
             else
             {
-              let nodes = self.select_nodes_from_table(&nodes_table, query.destination.clone())?;
+              let nodes = self.select_nodes_from_table(&nodes_table, &query.destination)?;
               for n in nodes.into_iter()
               {
-                let nkey = n.key;
+                let nkey = n.key();
                 for k in edges_destination_uuid_index
+                  .as_ref()
                   .borrow()
-                  .get_required(nkey, || InternalError::UnknownNode)?
+                  .get_required(PersistentKey(nkey), || InternalError::UnknownNode)?
                   .value()
                   .iter()
                 {
-                  let uniq_k = (k.to_owned(), None, Some(nkey));
+                  let uniq_k = (k.to_owned_key(), None, Some(nkey));
                   if !edge_ids.contains(&uniq_k)
                   {
                     edges_raw.push(EdgeIdResult::new(
@@ -684,20 +762,26 @@ impl Store
         let edge = v.edge_data;
 
         let source = nodes_table
-          .get_required(edge.source, || InternalError::UnknownNode)?
-          .value();
+          .get(edge.source)?
+          .ok_or(InternalError::UnknownNode)?
+          .value()
+          .into();
         let destination = nodes_table
           .get_required(edge.destination, || InternalError::UnknownNode)?
-          .value();
+          .value()
+          .into();
 
-        let edge = graph::Edge {
-          key: edge.key,
+        let edge = graph::Path::new(
+          edge.key.into(),
           source,
+          edge.labels,
+          edge.properties,
           destination,
-          labels: edge.labels,
-          properties: edge.properties,
-        };
-        super::EdgeResult { edge, reversed }
+        );
+        super::EdgeResult {
+          path: edge,
+          reversed,
+        }
       })
     });
     // Filter using the labels
@@ -709,7 +793,7 @@ impl Store
         {
           for l in labels.iter()
           {
-            if !e.edge.labels.contains(l)
+            if !e.path.labels().contains(l)
             {
               return false;
             }
@@ -728,7 +812,7 @@ impl Store
         {
           for (k, v) in properties.iter()
           {
-            match e.edge.properties.get(k)
+            match e.path.properties().get(k)
             {
               Some(val) =>
               {
@@ -754,11 +838,11 @@ impl Store
       r.filter(|e| {
         if let Ok(e) = &e
         {
-          query.is_match(&e.edge)
+          query.is_match(&e.path)
         }
         else
         {
-          return true;
+          true
         }
       })
       .collect()
@@ -786,17 +870,18 @@ impl store::Store for Store
   }
   fn graphs_list(&self, transaction: &mut Self::TransactionBox) -> Result<Vec<String>>
   {
-    self.get_metadata_value_or_else(transaction, "graphs".to_string(), || vec![])
+    self.get_metadata_value_or_else(transaction, "graphs".to_string(), Vec::new)
   }
   fn create_graph(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     ignore_if_exists: bool,
   ) -> Result<()>
   {
+    let graph_name = graph_name.as_ref();
     let mut graphs_list = self.graphs_list(transaction)?;
-    if graphs_list.contains(graph_name)
+    if graphs_list.iter().any(|s| s == graph_name)
     {
       if ignore_if_exists
       {
@@ -824,16 +909,21 @@ impl store::Store for Store
 
       self.graphs.write()?.insert(graph_name.to_owned(), gi);
     }
-    graphs_list.push(graph_name.clone());
+    graphs_list.push(graph_name.to_owned());
     self.set_metadata_value(transaction, "graphs", &graphs_list)?;
 
     Ok(())
   }
-  fn delete_graph(&self, transaction: &mut Self::TransactionBox, graph_name: &String)
-    -> Result<()>
+  fn drop_graph(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: impl AsRef<str>,
+    if_exists: bool,
+  ) -> Result<()>
   {
+    let graph_name = graph_name.as_ref();
     let mut graphs_list = self.graphs_list(transaction)?;
-    if graphs_list.contains(graph_name)
+    if graphs_list.iter().any(|s| s == graph_name)
     {
       {
         let tx = transaction.try_into_write()?;
@@ -848,6 +938,10 @@ impl store::Store for Store
 
       Ok(())
     }
+    else if if_exists
+    {
+      Ok(())
+    }
     else
     {
       Err(
@@ -859,10 +953,10 @@ impl store::Store for Store
     }
   }
   /// Create nodes and add them to a graph
-  fn create_nodes<'a, T: Iterator<Item = &'a crate::graph::Node>>(
+  fn create_nodes<'a, T: IntoIterator<Item = &'a crate::graph::Node>>(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     nodes_iter: T,
   ) -> Result<()>
   {
@@ -874,9 +968,10 @@ impl store::Store for Store
       transaction.open_table(graph_info.edges_destination_index_definition())?;
     for x in nodes_iter
     {
-      table.insert(x.key, x)?;
-      table_source.insert(x.key, vec![])?;
-      table_destination.insert(x.key, vec![])?;
+      let pk = PersistentKey(x.key());
+      table.insert(&pk, PersistentNode::Reference(x))?;
+      table_source.insert(&pk, vec![])?;
+      table_destination.insert(&pk, vec![])?;
     }
     Ok(())
   }
@@ -884,25 +979,26 @@ impl store::Store for Store
   fn update_node(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     node: &graph::Node,
   ) -> Result<()>
   {
     let graph_info = self.get_graph_info(graph_name)?;
     let transaction = transaction.try_into_write()?;
     let mut table = transaction.open_table(graph_info.nodes_table_definition())?;
-    table.insert(node.key, node)?;
+    table.insert(PersistentKey(node.key()), PersistentNode::Reference(node))?;
     Ok(())
   }
   /// Delete nodes according to a given query
   fn delete_nodes(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     query: super::SelectNodeQuery,
     detach: bool,
   ) -> Result<()>
   {
+    let graph_name = graph_name.as_ref();
     let graph_info = self.get_graph_info(graph_name)?;
 
     if query.is_select_all()
@@ -943,7 +1039,7 @@ impl store::Store for Store
         self
           .select_nodes(transaction, graph_name, query)?
           .into_iter()
-          .map(|x| x.key)
+          .map(|x| x.key())
           .collect()
       };
 
@@ -971,11 +1067,11 @@ impl store::Store for Store
         for key in node_keys.iter()
         {
           if !table_source
-            .get_required(key, || InternalError::UnknownNode)?
+            .get_required(PersistentKey(key.to_owned()), || InternalError::UnknownNode)?
             .value()
             .is_empty()
             || !table_destination
-              .get_required(key, || InternalError::UnknownNode)?
+              .get_required(PersistentKey(key.to_owned()), || InternalError::UnknownNode)?
               .value()
               .is_empty()
           {
@@ -992,9 +1088,9 @@ impl store::Store for Store
         write_transaction.open_table(graph_info.edges_destination_index_definition())?;
       for key in node_keys.into_iter()
       {
-        table_nodes.remove(key)?;
-        table_source.remove(key)?;
-        table_destination.remove(key)?;
+        table_nodes.remove(PersistentKey(key))?;
+        table_source.remove(PersistentKey(key))?;
+        table_destination.remove(PersistentKey(key))?;
       }
     }
     Ok(())
@@ -1003,30 +1099,31 @@ impl store::Store for Store
   fn select_nodes(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     query: super::SelectNodeQuery,
   ) -> Result<Vec<crate::graph::Node>>
   {
+    let graph_name = graph_name.as_ref();
     let graph_info = self.get_graph_info(graph_name)?;
     match transaction
     {
       store::TransactionBox::Read(read) =>
       {
         let nodes_table = read.open_table(graph_info.nodes_table_definition())?;
-        self.select_nodes_from_table(&nodes_table, query)
+        self.select_nodes_from_table(&nodes_table, &query)
       }
       store::TransactionBox::Write(write) =>
       {
         let nodes_table = write.open_table(graph_info.nodes_table_definition())?;
-        self.select_nodes_from_table(&nodes_table, query)
+        self.select_nodes_from_table(&nodes_table, &query)
       }
     }
   }
   /// Add edge
-  fn create_edges<'a, T: Iterator<Item = &'a crate::graph::Edge>>(
+  fn create_edges<'a, T: IntoIterator<Item = &'a crate::graph::SinglePath>>(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     edges_iter: T,
   ) -> Result<()>
   {
@@ -1040,62 +1137,59 @@ impl store::Store for Store
     for x in edges_iter
     {
       let mut keys_source = table_source
-        .remove(x.source.key)?
+        .remove(PersistentKey(x.source().key()))?
         .ok_or(InternalError::UnknownNode)?
         .value();
-      keys_source.push(x.key);
+      keys_source.push(x.key().into());
       let mut keys_destination = table_destination
-        .remove(x.destination.key)?
+        .remove(PersistentKey(x.destination().key()))?
         .ok_or(InternalError::UnknownNode)?
         .value();
-      keys_destination.push(x.key);
+      keys_destination.push(x.key().into());
 
       table.insert(
-        x.key,
+        PersistentKey(x.key()),
         &PersistentEdge {
-          key: x.key,
-          source: x.source.key,
-          destination: x.destination.key,
-          labels: x.labels.clone(),
-          properties: x.properties.clone(),
+          key: x.key().into(),
+          source: x.source().key().into(),
+          destination: x.destination().key().into(),
+          labels: x.labels().clone(),
+          properties: x.properties().clone(),
         },
       )?;
-      table_source.insert(x.source.key, keys_source)?;
-      table_destination.insert(x.destination.key, keys_destination)?;
+      table_source.insert(PersistentKey(x.source().key()), keys_source)?;
+      table_destination.insert(PersistentKey(x.destination().key()), keys_destination)?;
     }
     Ok(())
   }
   fn update_edge(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     edge: &graph::Edge,
   ) -> Result<()>
   {
     let transaction = transaction.try_into_write()?;
     let graph_info = self.get_graph_info(graph_name)?;
     let mut table = transaction.open_table(graph_info.edges_table_definition())?;
-    table.insert(
-      edge.key,
-      &PersistentEdge {
-        key: edge.key,
-        source: edge.source.key,
-        destination: edge.destination.key,
-        labels: edge.labels.to_owned(),
-        properties: edge.properties.to_owned(),
-      },
-    )?;
+    let mut pe = table
+      .get_required(&edge.key().into(), || InternalError::UnknownEdge)?
+      .value();
+    pe.labels = edge.labels().to_owned();
+    pe.properties = edge.properties().to_owned();
+    table.insert(PersistentKey(edge.key()), &pe)?;
     Ok(())
   }
   /// Delete nodes according to a given query
   fn delete_edges(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     query: super::SelectEdgeQuery,
     directivity: graph::EdgeDirectivity,
   ) -> Result<()>
   {
+    let graph_name = graph_name.as_ref();
     let graph_info = self.get_graph_info(graph_name)?;
     let edges = self.select_edges(transaction, graph_name, query, directivity)?;
 
@@ -1108,29 +1202,29 @@ impl store::Store for Store
 
     for e in edges
     {
-      table.remove(e.edge.key)?;
+      table.remove(PersistentKey(e.path.key()))?;
       let (sk, dk) = if e.reversed
       {
-        (e.edge.destination.key, e.edge.source.key)
+        (e.path.destination().key(), e.path.source().key())
       }
       else
       {
-        (e.edge.source.key, e.edge.destination.key)
+        (e.path.source().key(), e.path.destination().key())
       };
 
       let mut v = table_source
-        .remove(sk)?
+        .remove(PersistentKey(sk))?
         .ok_or_else(|| InternalError::UnknownNode)?
         .value();
-      v.retain(|x| *x != e.edge.key);
-      table_source.insert(sk, v)?;
+      v.retain(|x| *x != e.path.key().into());
+      table_source.insert(PersistentKey(sk), v)?;
 
       let mut v = table_destination
-        .remove(dk)?
+        .remove(PersistentKey(dk))?
         .ok_or_else(|| InternalError::UnknownNode)?
         .value();
-      v.retain(|x| *x != e.edge.key);
-      table_destination.insert(dk, v)?;
+      v.retain(|x| *x != e.path.key().into());
+      table_destination.insert(PersistentKey(dk), v)?;
     }
     Ok(())
   }
@@ -1138,7 +1232,7 @@ impl store::Store for Store
   fn select_edges(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     query: super::SelectEdgeQuery,
     directivity: graph::EdgeDirectivity,
   ) -> Result<Vec<super::EdgeResult>>
@@ -1203,14 +1297,10 @@ impl store::Store for Store
     let mut labels = Vec::new();
     let mut properties_count = 0;
 
-    for n in self.select_nodes(
-      transaction,
-      &"default".into(),
-      super::SelectNodeQuery::select_all(),
-    )?
+    for n in self.select_nodes(transaction, "default", super::SelectNodeQuery::select_all())?
     {
       nodes_count += 1;
-      for l in n.labels.iter()
+      for l in n.labels().iter()
       {
         if !labels.contains(l)
         {
@@ -1218,14 +1308,14 @@ impl store::Store for Store
         }
       }
       properties_count += n
-        .properties
+        .properties()
         .iter()
         .filter(|(_, v)| **v != value::Value::Null)
         .count();
     }
     for e in self.select_edges(
       transaction,
-      &"default".into(),
+      "default",
       super::SelectEdgeQuery::select_all(),
       graph::EdgeDirectivity::Directed,
     )?
@@ -1233,8 +1323,8 @@ impl store::Store for Store
       edges_count += 1;
 
       properties_count += e
-        .edge
-        .properties
+        .path
+        .properties()
         .iter()
         .filter(|(_, v)| **v != value::Value::Null)
         .count();