gqlite 1.2.3 → 1.3.0

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

@@ -1,7 +1,5 @@
 use std::{cell::RefCell, collections::HashSet, path::PathBuf};
 
-use rusqlite;
-
 use askama::Template;
 use ccutils::pool::{self, Pool};
 use rusqlite::{named_params, types::FromSql, OptionalExtension, ToSql};
@@ -19,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))
   }
 }
 
@@ -141,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,
@@ -189,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,
@@ -239,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,
   }
 }
 
@@ -251,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);
@@ -330,7 +336,7 @@ impl Store
         (),
       )?;
       self.set_metadata_value_json(&mut tx, "graphs", &Vec::<String>::new())?;
-      self.create_graph(&mut tx, &"default".to_string(), true)?;
+      self.create_graph(&mut tx, "default", true)?;
     }
     self.set_metadata_value_json(&mut tx, "version", &consts::GQLITE_VERSION)?;
     tx.close()?;
@@ -339,19 +345,14 @@ impl Store
   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)
     {
@@ -526,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
       {
@@ -547,13 +549,9 @@ 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(())
@@ -561,20 +559,17 @@ impl store::Store for Store
   fn drop_graph(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    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)?;
 
@@ -594,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<()>
   {
@@ -605,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())?,
         ),
       )?;
     }
@@ -621,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()?
@@ -644,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()?
@@ -659,7 +655,7 @@ impl store::Store for Store
     }
     transaction.get_connection().execute(
       templates::NodeDelete {
-        graph_name: &graph_name,
+        graph_name,
         keys: &nodes_keys,
       }
       .render()?
@@ -671,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(())
@@ -692,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(),
@@ -709,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
@@ -730,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<()>
   {
@@ -752,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()),
         ),
       )?;
     }
@@ -770,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()?
@@ -791,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(())
@@ -812,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>>
@@ -828,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(),
@@ -850,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
@@ -865,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
@@ -880,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
@@ -905,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)?)?;
 
@@ -924,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
       {
@@ -945,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,
       });
     }
@@ -963,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(),
@@ -990,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"
     );
   }