gqlite 1.2.2 → 1.3.0

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

@@ -17,23 +17,31 @@ use crate::{
 //   |_|\___/|_|  |_|  \___/|_| |_| |_|____/ \__, |_|
 //                                              |_|
 
-impl rusqlite::ToSql for graph::Key
+ccutils::alias!(PersistentKey, graph::Key, derive: Debug, PartialEq);
+
+impl rusqlite::ToSql for PersistentKey
 {
   fn to_sql(&self) -> rusqlite::Result<rusqlite::types::ToSqlOutput<'_>>
   {
     Ok(rusqlite::types::ToSqlOutput::Owned(
-      rusqlite::types::Value::Blob(self.uuid.to_be_bytes().into()),
+      rusqlite::types::Value::Blob(self.uuid().to_be_bytes().into()),
     ))
   }
 }
 
-impl rusqlite::types::FromSql for graph::Key
+impl rusqlite::types::FromSql for PersistentKey
 {
   fn column_result(value: rusqlite::types::ValueRef<'_>) -> rusqlite::types::FromSqlResult<Self>
   {
-    Ok(Self {
-      uuid: u128::from_be_bytes(<[u8; 16]>::column_result(value)?),
-    })
+    Ok(u128::from_be_bytes(<[u8; 16]>::column_result(value)?).into())
+  }
+}
+
+impl From<u128> for PersistentKey
+{
+  fn from(value: u128) -> Self
+  {
+    Self(graph::Key::new(value))
   }
 }
 
@@ -139,45 +147,45 @@ mod templates
   #[template(path = "sql/sqlite/upgrade_graph_from_1_01.sql", escape = "none")]
   pub(super) struct UpgradeGraphFrom1_01<'a>
   {
-    pub graph_name: &'a String,
+    pub graph_name: &'a str,
   }
   #[derive(Template)]
   #[template(path = "sql/sqlite/graph_create.sql", escape = "none")]
   pub(super) struct GraphCreate<'a>
   {
-    pub graph_name: &'a String,
+    pub graph_name: &'a str,
   }
   #[derive(Template)]
   #[template(path = "sql/sqlite/graph_delete.sql", escape = "none")]
   pub(super) struct GraphDelete<'a>
   {
-    pub graph_name: &'a String,
+    pub graph_name: &'a str,
   }
   // Node related templates
   #[derive(Template)]
   #[template(path = "sql/sqlite/node_create.sql", escape = "none")]
   pub(super) struct NodeCreate<'a>
   {
-    pub graph_name: &'a String,
+    pub graph_name: &'a str,
   }
   #[derive(Template)]
   #[template(path = "sql/sqlite/node_delete.sql", escape = "none")]
   pub(super) struct NodeDelete<'a>
   {
-    pub graph_name: &'a String,
+    pub graph_name: &'a str,
     pub keys: &'a Vec<String>,
   }
   #[derive(Template)]
   #[template(path = "sql/sqlite/node_update.sql", escape = "none")]
   pub(super) struct NodeUpdate<'a>
   {
-    pub graph_name: &'a String,
+    pub graph_name: &'a str,
   }
   #[derive(Template)]
   #[template(path = "sql/sqlite/node_select.sql", escape = "none")]
   pub(super) struct NodeSelect<'a>
   {
-    pub graph_name: &'a String,
+    pub graph_name: &'a str,
     pub has_keys: bool,
     pub has_labels: bool,
     pub has_properties: bool,
@@ -187,40 +195,40 @@ mod templates
   #[template(path = "sql/sqlite/edge_count_for_node.sql", escape = "none")]
   pub(super) struct EdgeCountForNode<'a>
   {
-    pub graph_name: &'a String,
+    pub graph_name: &'a str,
     pub keys: &'a Vec<String>,
   }
   #[derive(Template)]
   #[template(path = "sql/sqlite/edge_create.sql", escape = "none")]
   pub(super) struct EdgeCreate<'a>
   {
-    pub graph_name: &'a String,
+    pub graph_name: &'a str,
   }
   #[derive(Template)]
   #[template(path = "sql/sqlite/edge_delete_by_nodes.sql", escape = "none")]
   pub(super) struct EdgeDeleteByNodes<'a>
   {
-    pub graph_name: &'a String,
+    pub graph_name: &'a str,
     pub keys: &'a Vec<String>,
   }
   #[derive(Template)]
   #[template(path = "sql/sqlite/edge_delete.sql", escape = "none")]
   pub(super) struct EdgeDelete<'a>
   {
-    pub graph_name: &'a String,
+    pub graph_name: &'a str,
     pub keys: &'a Vec<String>,
   }
   #[derive(Template)]
   #[template(path = "sql/sqlite/edge_update.sql", escape = "none")]
   pub(super) struct EdgeUpdate<'a>
   {
-    pub graph_name: &'a String,
+    pub graph_name: &'a str,
   }
   #[derive(Template)]
   #[template(path = "sql/sqlite/edge_select.sql", escape = "none")]
   pub(super) struct EdgeSelect<'a>
   {
-    pub graph_name: &'a String,
+    pub graph_name: &'a str,
     pub is_undirected: bool,
     pub table_suffix: &'a str,
     pub has_edge_keys: bool,
@@ -237,7 +245,7 @@ mod templates
   #[template(path = "sql/sqlite/call_stats.sql", escape = "none")]
   pub(super) struct CallStats<'a>
   {
-    pub graph_name: &'a String,
+    pub graph_name: &'a str,
   }
 }
 
@@ -249,14 +257,14 @@ mod templates
 
 type TransactionBox = store::TransactionBox<ReadTransaction, WriteTransaction>;
 
-fn hex(key: &graph::Key) -> String
+fn hex(key: impl Into<graph::Key>) -> String
 {
-  format!("{:032X}", key.uuid)
+  format!("{:032X}", key.into().uuid())
 }
 
 pub(crate) struct Store
 {
-  connection: Pool<rusqlite::Connection, Error>,
+  connection: Pool<rusqlite::Connection, ErrorType>,
 }
 
 ccutils::assert_impl_all!(Store: Sync, Send);
@@ -264,35 +272,55 @@ ccutils::assert_impl_all!(Store: Sync, Send);
 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>
   {
-    use store::Store;
     let path: PathBuf = path.as_ref().into();
     let connection = Pool::new(
       move || Ok(rusqlite::Connection::open(&path)?),
       pool::Options::default().minimum_pool_size(1).pool_size(3),
     )?;
     let s = Self { connection };
-
-    let mut tx = s.begin_write()?;
-    if s.check_if_table_exists(&mut tx, "gqlite_metadata")?
+    s.initialise()?;
+    Ok(s)
+  }
+  pub(crate) fn in_memory() -> Result<Store>
+  {
+    let id = uuid::Uuid::new_v4().as_u128();
+    let connection = Pool::new(
+      move || {
+        Ok(rusqlite::Connection::open_with_flags(
+          format!("file:{}?mode=memory&cache=shared", id),
+          rusqlite::OpenFlags::default(),
+        )?)
+      },
+      pool::Options::default().minimum_pool_size(1).pool_size(3),
+    )?;
+    let s = Self { connection };
+    s.initialise()?;
+    Ok(s)
+  }
+  fn initialise(&self) -> Result<()>
+  {
+    use store::Store;
+    let mut tx = self.begin_write()?;
+    if self.check_if_table_exists(&mut tx, "gqlite_metadata")?
     {
       // gqlite version 1.1 incorrectly use ' instead of " in the version number
-      let version_raw = s
+      let version_raw = self
         .get_metadata_value::<String>(&mut tx, "version")?
         .replace("'", "\"");
       let version: utils::Version = serde_json::from_str(&version_raw)?;
       if version.major != consts::GQLITE_VERSION.major
         || version.minor != consts::GQLITE_VERSION.minor
       {
-        s.upgrade_database(&mut tx, version)?;
+        self.upgrade_database(&mut tx, version)?;
       }
     }
-    else if !s.check_if_table_exists(&mut tx, "gqlite_metadata")?
-      && s.check_if_table_exists(&mut tx, "gqlite_default_nodes")?
+    else if !self.check_if_table_exists(&mut tx, "gqlite_metadata")?
+      && self.check_if_table_exists(&mut tx, "gqlite_default_nodes")?
     {
       // 1.0 didn't have the metadata table
-      s.upgrade_database(
+      self.upgrade_database(
         &mut tx,
         utils::Version {
           major: 1,
@@ -307,29 +335,24 @@ impl Store
         include_str!("../../templates/sql/sqlite/metadata_create_table.sql"),
         (),
       )?;
-      s.set_metadata_value_json(&mut tx, "graphs", &Vec::<String>::new())?;
-      s.create_graph(&mut tx, &"default".to_string(), true)?;
+      self.set_metadata_value_json(&mut tx, "graphs", &Vec::<String>::new())?;
+      self.create_graph(&mut tx, "default", true)?;
     }
-    s.set_metadata_value_json(&mut tx, "version", &consts::GQLITE_VERSION)?;
+    self.set_metadata_value_json(&mut tx, "version", &consts::GQLITE_VERSION)?;
     tx.close()?;
-    Ok(s)
+    Ok(())
   }
   fn upgrade_database(&self, transaction: &mut TransactionBox, from: utils::Version) -> Result<()>
   {
     use crate::store::Store;
-    match (from.major, from.minor)
+    if let (1, 0) = (from.major, from.minor)
     {
-      (1, 0) =>
-      {
-        // Create a metadata table and add the default graph.
-        transaction.get_connection().execute(
-          include_str!("../../templates/sql/sqlite/metadata_create_table.sql"),
-          (),
-        )?;
-        self.set_metadata_value_json(transaction, "graphs", &vec!["default".to_string()])?;
-      }
-      _ =>
-      {}
+      // Create a metadata table and add the default graph.
+      transaction.get_connection().execute(
+        include_str!("../../templates/sql/sqlite/metadata_create_table.sql"),
+        (),
+      )?;
+      self.set_metadata_value_json(transaction, "graphs", &vec!["default".to_string()])?;
     }
     match (from.major, from.minor)
     {
@@ -394,6 +417,7 @@ impl Store
       |row| row.get(0),
     )?)
   }
+  #[allow(dead_code)]
   pub(crate) fn get_metadata_value_or_else<T: FromSql>(
     &self,
     transaction: &mut TransactionBox,
@@ -437,6 +461,7 @@ impl Store
       &self.get_metadata_value::<String>(transaction, key)?,
     )?)
   }
+  #[allow(dead_code)]
   pub(crate) fn get_metadata_value_json_or_else<T: for<'a> Deserialize<'a>>(
     &self,
     transaction: &mut TransactionBox,
@@ -502,12 +527,13 @@ impl store::Store for Store
   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
       {
@@ -523,35 +549,36 @@ impl store::Store for Store
         );
       }
     }
-    transaction.get_connection().execute_batch(
-      templates::GraphCreate {
-        graph_name: &graph_name,
-      }
-      .render()?
-      .as_str(),
-    )?;
+    transaction
+      .get_connection()
+      .execute_batch(templates::GraphCreate { graph_name }.render()?.as_str())?;
     graphs_list.push(graph_name.to_owned());
     self.set_metadata_value_json(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)
     {
-      transaction.get_connection().execute_batch(
-        templates::GraphDelete {
-          graph_name: &graph_name,
-        }
-        .render()?
-        .as_str(),
-      )?;
+      transaction
+        .get_connection()
+        .execute_batch(templates::GraphDelete { graph_name }.render()?.as_str())?;
       graphs_list.retain(|x| x != graph_name);
       self.set_metadata_value_json(transaction, "graphs", &graphs_list)?;
 
       Ok(())
     }
+    else if if_exists
+    {
+      Ok(())
+    }
     else
     {
       Err(
@@ -562,10 +589,10 @@ impl store::Store for Store
       )
     }
   }
-  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<()>
   {
@@ -573,14 +600,14 @@ impl store::Store for Store
     {
       transaction.get_connection().execute(
         templates::NodeCreate {
-          graph_name: graph_name.into(),
+          graph_name: graph_name.as_ref(),
         }
         .render()?
         .as_str(),
         (
-          x.key,
-          serde_json::to_string(&x.labels)?,
-          serde_json::to_string(&x.properties)?,
+          PersistentKey(x.key()),
+          serde_json::to_string(x.labels())?,
+          serde_json::to_string(x.properties())?,
         ),
       )?;
     }
@@ -589,18 +616,19 @@ impl store::Store for Store
   fn delete_nodes(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     query: store::SelectNodeQuery,
     detach: bool,
   ) -> Result<()>
   {
+    let graph_name = graph_name.as_ref();
     let nodes = self.select_nodes(transaction, graph_name, query)?;
-    let nodes_keys: Vec<String> = nodes.into_iter().map(|x| hex(&x.key)).collect();
+    let nodes_keys: Vec<String> = nodes.into_iter().map(|x| hex(x.key())).collect();
     if detach
     {
       transaction.get_connection().execute(
         templates::EdgeDeleteByNodes {
-          graph_name: &graph_name.into(),
+          graph_name,
           keys: &nodes_keys,
         }
         .render()?
@@ -612,7 +640,7 @@ impl store::Store for Store
     {
       let count = transaction.get_connection().query_row(
         templates::EdgeCountForNode {
-          graph_name: &graph_name,
+          graph_name,
           keys: &nodes_keys,
         }
         .render()?
@@ -627,7 +655,7 @@ impl store::Store for Store
     }
     transaction.get_connection().execute(
       templates::NodeDelete {
-        graph_name: &graph_name,
+        graph_name,
         keys: &nodes_keys,
       }
       .render()?
@@ -639,20 +667,20 @@ impl store::Store for Store
   fn update_node(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     node: &crate::graph::Node,
   ) -> Result<()>
   {
     transaction.get_connection().execute(
       templates::NodeUpdate {
-        graph_name: &graph_name,
+        graph_name: graph_name.as_ref(),
       }
       .render()?
       .as_str(),
       named_params! {
-        ":key": node.key,
-        ":labels": serde_json::to_string(&node.labels)?,
-        ":properties": serde_json::to_string(&node.properties)?
+        ":key": PersistentKey(node.key()),
+        ":labels": serde_json::to_string(node.labels())?,
+        ":properties": serde_json::to_string(node.properties())?
       },
     )?;
     Ok(())
@@ -660,13 +688,13 @@ impl store::Store for Store
   fn select_nodes(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     query: store::SelectNodeQuery,
   ) -> Result<Vec<crate::graph::Node>>
   {
     let mut prepared_query = transaction.get_connection().prepare(
       templates::NodeSelect {
-        graph_name: graph_name.into(),
+        graph_name: graph_name.as_ref(),
         has_keys: query.keys.is_some(),
         has_labels: query.labels.is_some(),
         has_properties: query.properties.is_some(),
@@ -677,7 +705,7 @@ impl store::Store for Store
     let mut bindings = Vec::<(&'static str, String)>::new();
     if let Some(keys) = query.keys
     {
-      let hex_keys = keys.iter().map(|key| hex(key)).collect::<Vec<_>>();
+      let hex_keys = keys.iter().map(|key| hex(*key)).collect::<Vec<_>>();
       bindings.push((":keys", serde_json::to_string(&hex_keys)?));
     }
     if let Some(labels) = query.labels
@@ -698,21 +726,17 @@ impl store::Store for Store
     let mut nodes: Vec<graph::Node> = Default::default();
     while let Some(row) = it.next()?
     {
-      let key = row.get(0)?;
+      let key: graph::Key = row.get::<_, PersistentKey>(0)?.into();
       let labels = serde_json::from_str(&row.get::<_, String>(1)?)?;
       let properties = serde_json::from_str(&row.get::<_, String>(2)?)?;
-      nodes.push(graph::Node {
-        key,
-        labels,
-        properties,
-      });
+      nodes.push(graph::Node::new(key, labels, properties));
     }
     Ok(nodes)
   }
-  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<()>
   {
@@ -720,16 +744,16 @@ impl store::Store for Store
     {
       transaction.get_connection().execute(
         templates::EdgeCreate {
-          graph_name: graph_name.into(),
+          graph_name: graph_name.as_ref(),
         }
         .render()?
         .as_str(),
         (
-          x.key,
-          serde_json::to_string(&x.labels)?,
-          serde_json::to_string(&x.properties)?,
-          x.source.key,
-          x.destination.key,
+          PersistentKey(x.key()),
+          serde_json::to_string(x.labels())?,
+          serde_json::to_string(x.properties())?,
+          PersistentKey(x.source().key()),
+          PersistentKey(x.destination().key()),
         ),
       )?;
     }
@@ -738,16 +762,17 @@ impl store::Store for Store
   fn delete_edges(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     query: store::SelectEdgeQuery,
     directivity: crate::graph::EdgeDirectivity,
   ) -> Result<()>
   {
+    let graph_name = graph_name.as_ref();
     let edges = self.select_edges(transaction, graph_name, query, directivity)?;
-    let edges_keys: Vec<String> = edges.into_iter().map(|x| hex(&x.edge.key)).collect();
+    let edges_keys: Vec<String> = edges.into_iter().map(|x| hex(x.path.key())).collect();
     transaction.get_connection().execute(
       templates::EdgeDelete {
-        graph_name: &graph_name,
+        graph_name,
         keys: &edges_keys,
       }
       .render()?
@@ -759,20 +784,20 @@ impl store::Store for Store
   fn update_edge(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     edge: &crate::graph::Edge,
   ) -> Result<()>
   {
     transaction.get_connection().execute(
       templates::EdgeUpdate {
-        graph_name: &graph_name,
+        graph_name: graph_name.as_ref(),
       }
       .render()?
       .as_str(),
       named_params! {
-        ":key": edge.key,
-        ":labels": serde_json::to_string(&edge.labels)?,
-        ":properties": serde_json::to_string(&edge.properties)?
+        ":key": PersistentKey(edge.key().to_owned()),
+        ":labels": serde_json::to_string(edge.labels())?,
+        ":properties": serde_json::to_string(edge.properties())?
       },
     )?;
     Ok(())
@@ -780,7 +805,7 @@ impl store::Store for Store
   fn select_edges(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     query: store::SelectEdgeQuery,
     directivity: crate::graph::EdgeDirectivity,
   ) -> Result<Vec<store::EdgeResult>>
@@ -796,9 +821,9 @@ impl store::Store for Store
     };
     let mut prepared_query = transaction.get_connection().prepare(
       templates::EdgeSelect {
-        graph_name: graph_name,
+        graph_name: graph_name.as_ref(),
         is_undirected,
-        table_suffix: table_suffix,
+        table_suffix,
         has_edge_keys: query.keys.is_some(),
         has_edge_labels: query.labels.is_some(),
         has_edge_properties: query.properties.is_some(),
@@ -818,7 +843,7 @@ impl store::Store for Store
     // Edge queries
     if let Some(keys) = query.keys
     {
-      let hex_keys = keys.iter().map(|key| hex(&key)).collect::<Vec<_>>();
+      let hex_keys = keys.iter().map(|key| hex(*key)).collect::<Vec<_>>();
       bindings.push((":edge_keys", serde_json::to_string(&hex_keys)?));
     }
     if let Some(labels) = query.labels
@@ -833,7 +858,7 @@ impl store::Store for Store
     // Left queries
     if let Some(keys) = query.source.keys
     {
-      let hex_keys = keys.iter().map(|key| hex(&key)).collect::<Vec<_>>();
+      let hex_keys = keys.iter().map(|key| hex(*key)).collect::<Vec<_>>();
       bindings.push((":n_left_keys", serde_json::to_string(&hex_keys)?));
     }
     if let Some(labels) = query.source.labels
@@ -848,7 +873,7 @@ impl store::Store for Store
     // Right queries
     if let Some(keys) = query.destination.keys
     {
-      let hex_keys = keys.iter().map(|key| hex(&key)).collect::<Vec<_>>();
+      let hex_keys = keys.iter().map(|key| hex(*key)).collect::<Vec<_>>();
       bindings.push((":n_right_keys", serde_json::to_string(&hex_keys)?));
     }
     if let Some(labels) = query.destination.labels
@@ -873,16 +898,16 @@ impl store::Store for Store
     let mut edges_keys: HashSet<u128> = Default::default();
     while let Some(row) = it.next()?
     {
-      let edge_key: graph::Key = row.get(0)?;
-      let n_left_key = row.get(4)?;
-      let n_right_key = row.get(7)?;
+      let edge_key: PersistentKey = row.get(0)?;
+      let n_left_key: PersistentKey = row.get(4)?;
+      let n_right_key: PersistentKey = row.get(7)?;
 
       // This ensure that if (a)-[]->(a) the edge is returned only once. But matching [a]-[]-[b] return the edge twice.
-      if n_left_key == n_right_key && edges_keys.contains(&edge_key.uuid)
+      if n_left_key == n_right_key && edges_keys.contains(&edge_key.uuid())
       {
         continue;
       }
-      edges_keys.insert(edge_key.uuid);
+      edges_keys.insert(edge_key.uuid());
       let edge_labels = serde_json::from_str(&row.get::<_, String>(1)?)?;
       let edge_properties = serde_json::from_str(&row.get::<_, String>(2)?)?;
 
@@ -892,16 +917,8 @@ impl store::Store for Store
       let n_right_labels = serde_json::from_str(&row.get::<_, String>(8)?)?;
       let n_right_properties = serde_json::from_str(&row.get::<_, String>(9)?)?;
 
-      let source = graph::Node {
-        key: n_left_key,
-        labels: n_left_labels,
-        properties: n_left_properties,
-      };
-      let destination = graph::Node {
-        key: n_right_key,
-        labels: n_right_labels,
-        properties: n_right_properties,
-      };
+      let source = graph::Node::new(n_left_key.into(), n_left_labels, n_left_properties);
+      let destination = graph::Node::new(n_right_key.into(), n_right_labels, n_right_properties);
       let reversed = row.get::<_, u32>(3)? == 1;
       let (source, destination) = if reversed
       {
@@ -913,13 +930,13 @@ impl store::Store for Store
       };
 
       edges.push(EdgeResult {
-        edge: graph::Edge {
-          key: edge_key,
-          labels: edge_labels,
-          properties: edge_properties,
+        path: graph::Path::new(
+          edge_key.into(),
           source,
+          edge_labels,
+          edge_properties,
           destination,
-        },
+        ),
         reversed,
       });
     }
@@ -931,7 +948,7 @@ impl store::Store for Store
     let (nodes_count, edges_count, labels_nodes_count, properties_count) =
       transaction.get_connection().query_row(
         templates::CallStats {
-          graph_name: &"default".to_string(),
+          graph_name: "default",
         }
         .render()?
         .as_str(),
@@ -958,13 +975,11 @@ mod tests
   fn test_hex()
   {
     assert_eq!(
-      super::hex(&graph::Key {
-        uuid: 18580062510968287067562660977870108180
-      }),
+      super::hex(graph::Key::new(18580062510968287067562660977870108180)),
       "0DFA63CEE7484B0DBFC407697F77F614"
     );
     assert_eq!(
-      super::hex(&graph::Key { uuid: 0 }),
+      super::hex(graph::Key::new(0)),
       "00000000000000000000000000000000"
     );
   }
@@ -972,7 +987,7 @@ mod tests
   fn test_sqlite_metadata()
   {
     let temp_file = crate::tests::create_tmp_file();
-    let store = super::Store::new(temp_file.path()).unwrap();
+    let store = super::Store::open(temp_file.path()).unwrap();
     let mut tx = store.begin_read().unwrap();
     let version: utils::Version = store.get_metadata_value_json(&mut tx, "version").unwrap();
     assert_eq!(version.major, consts::GQLITE_VERSION.major);
@@ -982,7 +997,7 @@ mod tests
     drop(store);
 
     // Try to reopen
-    let store = super::Store::new(temp_file.path()).unwrap();
+    let store = super::Store::open(temp_file.path()).unwrap();
     let mut tx = store.begin_read().unwrap();
     let version: utils::Version = store.get_metadata_value_json(&mut tx, "version").unwrap();
     assert_eq!(version.major, consts::GQLITE_VERSION.major);