gqlite 1.3.1 → 1.4.0

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

@@ -1,15 +1,17 @@
-use std::{cell::RefCell, collections::HashSet, path::PathBuf};
+use std::{cell::RefCell, path::PathBuf};
 
-use askama::Template;
 use ccutils::pool::{self, Pool};
-use rusqlite::{named_params, types::FromSql, OptionalExtension, ToSql};
-use serde::{Deserialize, Serialize};
 
 use crate::{
   prelude::*,
-  store::{EdgeResult, TransactionBoxable},
+  store::{sqlbase::SqlValue, TransactionBoxable},
 };
 
+ccutils::assert_impl_all!(Store: Sync, Send);
+
+use askama::Template;
+use rusqlite::named_params;
+
 //  _____     _____                    ____        _
 // |_   _|__ |  ___| __ ___  _ __ ___ / ___|  __ _| |
 //   | |/ _ \| |_ | '__/ _ \| '_ ` _ \\___ \ / _` | |
@@ -17,31 +19,38 @@ use crate::{
 //   |_|\___/|_|  |_|  \___/|_| |_| |_|____/ \__, |_|
 //                                              |_|
 
-ccutils::alias!(PersistentKey, graph::Key, derive: Debug, PartialEq);
-
-impl rusqlite::ToSql for PersistentKey
+impl<'a> rusqlite::ToSql for SqlValue<'a>
 {
   fn to_sql(&self) -> rusqlite::Result<rusqlite::types::ToSqlOutput<'_>>
   {
-    Ok(rusqlite::types::ToSqlOutput::Owned(
-      rusqlite::types::Value::Blob(self.uuid().to_be_bytes().into()),
-    ))
-  }
-}
-
-impl rusqlite::types::FromSql for PersistentKey
-{
-  fn column_result(value: rusqlite::types::ValueRef<'_>) -> rusqlite::types::FromSqlResult<Self>
-  {
-    Ok(u128::from_be_bytes(<[u8; 16]>::column_result(value)?).into())
+    match self
+    {
+      SqlValue::String(string) => string.to_sql(),
+      SqlValue::StringRef(string) => string.to_sql(),
+      SqlValue::Key(key) => Ok(rusqlite::types::ToSqlOutput::Owned(
+        rusqlite::types::Value::Blob(key.uuid().to_be_bytes().into()),
+      )),
+      SqlValue::Blob(data) => data.to_sql(),
+      SqlValue::Text(text) => std::str::from_utf8(text).unwrap().to_sql(),
+      SqlValue::Float(fl) => fl.to_sql(),
+      SqlValue::Integer(it) => it.to_sql(),
+      SqlValue::Null => rusqlite::types::Null.to_sql(),
+    }
   }
 }
 
-impl From<u128> for PersistentKey
+impl<'a> sqlbase::Row for rusqlite::Row<'a>
 {
-  fn from(value: u128) -> Self
+  fn get_value(&self, index: usize) -> Result<SqlValue<'_>>
   {
-    Self(graph::Key::new(value))
+    match self.get_ref(index)?
+    {
+      rusqlite::types::ValueRef::Blob(blob) => Ok(SqlValue::Blob(blob)),
+      rusqlite::types::ValueRef::Integer(int) => Ok(SqlValue::Integer(int)),
+      rusqlite::types::ValueRef::Null => Ok(SqlValue::Null),
+      rusqlite::types::ValueRef::Real(f) => Ok(SqlValue::Float(f)),
+      rusqlite::types::ValueRef::Text(txt) => Ok(SqlValue::Text(txt)),
+    }
   }
 }
 
@@ -186,9 +195,9 @@ mod templates
   pub(super) struct NodeSelect<'a>
   {
     pub graph_name: &'a str,
-    pub has_keys: bool,
-    pub has_labels: bool,
-    pub has_properties: bool,
+    pub keys_var: &'a Option<usize>,
+    pub labels_var: &'a Option<usize>,
+    pub properties_var: &'a Option<usize>,
   }
   // Edge queries
   #[derive(Template)]
@@ -231,15 +240,15 @@ mod templates
     pub graph_name: &'a str,
     pub is_undirected: bool,
     pub table_suffix: &'a str,
-    pub has_edge_keys: bool,
-    pub has_edge_labels: bool,
-    pub has_edge_properties: bool,
-    pub has_n_left_keys: bool,
-    pub has_n_left_labels: bool,
-    pub has_n_left_properties: bool,
-    pub has_n_right_keys: bool,
-    pub has_n_right_labels: bool,
-    pub has_n_right_properties: bool,
+    pub edge_keys_var: Option<usize>,
+    pub edge_labels_var: Option<usize>,
+    pub edge_properties_var: Option<usize>,
+    pub left_keys_var: Option<usize>,
+    pub left_labels_var: Option<usize>,
+    pub left_properties_var: Option<usize>,
+    pub right_keys_var: Option<usize>,
+    pub right_labels_var: Option<usize>,
+    pub right_properties_var: Option<usize>,
   }
   #[derive(Template)]
   #[template(path = "sql/sqlite/call_stats.sql", escape = "none")]
@@ -257,16 +266,10 @@ mod templates
 
 type TransactionBox = store::TransactionBox<ReadTransaction, WriteTransaction>;
 
-fn hex(key: impl Into<graph::Key>) -> String
-{
-  format!("{:032X}", key.into().uuid())
-}
-
 pub(crate) struct Store
 {
   connection: Pool<rusqlite::Connection, ErrorType>,
 }
-
 ccutils::assert_impl_all!(Store: Sync, Send);
 
 impl Store
@@ -299,49 +302,6 @@ impl Store
     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 = 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
-      {
-        self.upgrade_database(&mut tx, version)?;
-      }
-    }
-    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
-      self.upgrade_database(
-        &mut tx,
-        utils::Version {
-          major: 1,
-          minor: 0,
-          patch: 0,
-        },
-      )?;
-    }
-    else
-    {
-      tx.get_connection().execute(
-        include_str!("../../templates/sql/sqlite/metadata_create_table.sql"),
-        (),
-      )?;
-      self.set_metadata_value_json(&mut tx, "graphs", &Vec::<String>::new())?;
-      self.create_graph(&mut tx, "default", true)?;
-    }
-    self.set_metadata_value_json(&mut tx, "version", &consts::GQLITE_VERSION)?;
-    tx.close()?;
-    Ok(())
-  }
   fn upgrade_database(&self, transaction: &mut TransactionBox, from: utils::Version) -> Result<()>
   {
     use crate::store::Store;
@@ -405,100 +365,68 @@ impl Store
       |row| Ok(row.get::<_, i32>(0)? == 1),
     )?)
   }
-  pub(crate) fn get_metadata_value<T: FromSql>(
-    &self,
-    transaction: &mut TransactionBox,
-    key: impl Into<String>,
-  ) -> Result<T>
-  {
-    Ok(transaction.get_connection().query_row(
-      include_str!("../../templates/sql/sqlite/metadata_get.sql"),
-      named_params! {":name": key.into()},
-      |row| row.get(0),
-    )?)
-  }
-  #[allow(dead_code)]
-  pub(crate) fn get_metadata_value_or_else<T: FromSql>(
-    &self,
-    transaction: &mut TransactionBox,
-    key: impl Into<String>,
-    f: impl FnOnce() -> T,
-  ) -> Result<T>
-  {
-    Ok(
-      transaction
-        .get_connection()
-        .query_row(
-          include_str!("../../templates/sql/sqlite/metadata_get.sql"),
-          named_params! { ":name": key.into()},
-          |row| row.get(0),
-        )
-        .optional()
-        .map(|v| v.unwrap_or_else(f))?,
-    )
-  }
-  pub(crate) fn set_metadata_value(
-    &self,
-    transaction: &mut TransactionBox,
-    key: impl Into<String>,
-    value: &impl ToSql,
-  ) -> Result<()>
-  {
-    transaction.get_connection().execute(
-      include_str!("../../templates/sql/sqlite/metadata_set.sql"),
-      named_params! { ":name": key.into(), ":value": value },
-    )?;
-    Ok(())
-  }
+}
 
-  pub(crate) fn get_metadata_value_json<T: for<'a> Deserialize<'a>>(
-    &self,
-    transaction: &mut TransactionBox,
-    key: impl Into<String>,
-  ) -> Result<T>
-  {
-    Ok(serde_json::from_str(
-      &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,
-    key: impl Into<String>,
-    f: impl FnOnce() -> T,
-  ) -> Result<T>
+impl super::sqlbase::SqlMetaDataQueries for Store
+{
+  fn metadata_get_query() -> Result<String>
   {
-    Ok(
-      transaction
-        .get_connection()
-        .query_row(
-          include_str!("../../templates/sql/sqlite/metadata_get.sql"),
-          named_params! {":name": key.into()},
-          |row| row.get::<_, String>(0),
-        )
-        .optional()
-        .map(|v| {
-          v.map(|x| serde_json::from_str(&x))
-            .unwrap_or_else(|| Ok(f()))
-        })??,
-    )
+    Ok(include_str!("../../templates/sql/sqlite/metadata_get.sql").to_string())
   }
-  pub(crate) fn set_metadata_value_json(
-    &self,
-    transaction: &mut TransactionBox,
-    key: impl Into<String>,
-    value: &impl Serialize,
-  ) -> Result<()>
+  fn metadata_set_query() -> Result<String>
   {
-    self.set_metadata_value(transaction, key, &serde_json::to_string(value)?)
+    Ok(include_str!("../../templates/sql/sqlite/metadata_set.sql").to_string())
   }
 }
 
-impl store::Store for Store
+impl super::sqlbase::SqlStore for Store
 {
   type TransactionBox = TransactionBox;
-  fn begin_read(&self) -> Result<Self::TransactionBox>
+  type Row<'a> = rusqlite::Row<'a>;
+  fn initialise(&self) -> Result<()>
+  {
+    use store::Store;
+    let mut tx = self.begin_sql_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 = 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
+      {
+        self.upgrade_database(&mut tx, version)?;
+      }
+    }
+    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
+      self.upgrade_database(
+        &mut tx,
+        utils::Version {
+          major: 1,
+          minor: 0,
+          patch: 0,
+        },
+      )?;
+    }
+    else
+    {
+      tx.get_connection().execute(
+        include_str!("../../templates/sql/sqlite/metadata_create_table.sql"),
+        (),
+      )?;
+      self.set_metadata_value_json(&mut tx, "graphs", &Vec::<String>::new())?;
+      self.create_graph(&mut tx, "default", true)?;
+    }
+    self.set_metadata_value_json(&mut tx, "version", &consts::GQLITE_VERSION)?;
+    tx.close()?;
+    Ok(())
+  }
+  fn begin_sql_read(&self) -> Result<Self::TransactionBox>
   {
     let connection = self.connection.get()?;
     connection.execute("BEGIN", ())?;
@@ -509,7 +437,7 @@ impl store::Store for Store
       },
     }))
   }
-  fn begin_write(&self) -> Result<Self::TransactionBox>
+  fn begin_sql_write(&self) -> Result<Self::TransactionBox>
   {
     let connection = self.connection.get()?;
     connection.execute("BEGIN", ())?;
@@ -520,475 +448,245 @@ impl store::Store for Store
       },
     }))
   }
-  fn graphs_list(&self, transaction: &mut Self::TransactionBox) -> Result<Vec<String>>
+
+  fn execute_batch(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    sql: impl AsRef<str>,
+  ) -> Result<()>
   {
-    self.get_metadata_value_json(transaction, "graphs")
+    Ok(transaction.get_connection().execute_batch(sql.as_ref())?)
   }
-  fn create_graph(
+  fn execute<'a>(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: impl AsRef<str>,
-    ignore_if_exists: bool,
+    sql: impl AsRef<str>,
+    bindings: impl sqlbase::IntoBindings<'a>,
   ) -> Result<()>
   {
-    let graph_name = graph_name.as_ref();
-    let mut graphs_list = self.graphs_list(transaction)?;
-    if graphs_list.iter().any(|s| s == graph_name)
+    transaction.get_connection().execute(
+      sql.as_ref(),
+      rusqlite::params_from_iter(bindings.into_bindings_iter()),
+    )?;
+    Ok(())
+  }
+  fn query_rows<'a, 'tx>(
+    &self,
+    transaction: &'tx mut Self::TransactionBox,
+    sql: impl AsRef<str>,
+    bindings: impl sqlbase::IntoBindings<'a>,
+    mut f: impl for<'b> FnMut(&Self::Row<'b>) -> Result<()>,
+  ) -> Result<()>
+  {
+    let mut statement = transaction.get_connection().prepare(sql.as_ref())?;
+    let mut rows = statement.query(rusqlite::params_from_iter(bindings.into_bindings_iter()))?;
+    loop
     {
-      if ignore_if_exists
-      {
-        return Ok(());
-      }
-      else
+      let row = rows.next()?;
+      match row
       {
-        return Err(
-          StoreError::DuplicatedGraph {
-            graph_name: graph_name.to_owned(),
-          }
-          .into(),
-        );
+        Some(row) => f(row)?,
+        None => break,
       }
     }
-    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 drop_graph(
+  fn query_row<'a, 'tx, T>(
     &self,
-    transaction: &mut Self::TransactionBox,
-    graph_name: impl AsRef<str>,
-    if_exists: bool,
-  ) -> Result<()>
+    transaction: &'tx mut Self::TransactionBox,
+    sql: impl AsRef<str>,
+    bindings: impl sqlbase::IntoBindings<'a>,
+    f: impl for<'b> FnOnce(&Self::Row<'b>) -> Result<T>,
+  ) -> Result<T>
   {
-    let graph_name = graph_name.as_ref();
-    let mut graphs_list = self.graphs_list(transaction)?;
-    if graphs_list.iter().any(|s| s == graph_name)
-    {
-      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)?;
+    transaction.get_connection().query_row(
+      sql.as_ref(),
+      rusqlite::params_from_iter(bindings.into_bindings_iter()),
+      |row| Ok(f(row)),
+    )?
+  }
+}
 
-      Ok(())
-    }
-    else if if_exists
-    {
-      Ok(())
-    }
-    else
-    {
-      Err(
-        StoreError::UnknownGraph {
-          graph_name: graph_name.to_owned(),
-        }
-        .into(),
-      )
-    }
+impl super::sqlbase::SqlQueries for Store
+{
+  fn graph_create_query(graph_name: impl AsRef<str>) -> Result<String>
+  {
+    Ok(
+      templates::GraphCreate {
+        graph_name: graph_name.as_ref(),
+      }
+      .render()?,
+    )
   }
-  fn create_nodes<'a, T: IntoIterator<Item = &'a crate::graph::Node>>(
-    &self,
-    transaction: &mut Self::TransactionBox,
+  fn graph_delete(graph_name: impl AsRef<str>) -> Result<String>
+  {
+    Ok(
+      templates::GraphDelete {
+        graph_name: graph_name.as_ref(),
+      }
+      .render()?,
+    )
+  }
+  fn node_create_query(graph_name: impl AsRef<str>) -> Result<String>
+  {
+    Ok(
+      templates::NodeCreate {
+        graph_name: graph_name.as_ref(),
+      }
+      .render()?,
+    )
+  }
+  fn edge_delete_by_nodes_query(
     graph_name: impl AsRef<str>,
-    nodes_iter: T,
-  ) -> Result<()>
+    keys: impl AsRef<Vec<String>>,
+  ) -> Result<String>
   {
-    for x in nodes_iter
-    {
-      transaction.get_connection().execute(
-        templates::NodeCreate {
-          graph_name: graph_name.as_ref(),
-        }
-        .render()?
-        .as_str(),
-        (
-          PersistentKey(x.key()),
-          serde_json::to_string(x.labels())?,
-          serde_json::to_string(x.properties())?,
-        ),
-      )?;
-    }
-    Ok(())
+    Ok(
+      templates::EdgeDeleteByNodes {
+        graph_name: graph_name.as_ref(),
+        keys: keys.as_ref(),
+      }
+      .render()?,
+    )
   }
-  fn delete_nodes(
-    &self,
-    transaction: &mut Self::TransactionBox,
+
+  fn edge_count_for_nodes_query(
     graph_name: impl AsRef<str>,
-    query: store::SelectNodeQuery,
-    detach: bool,
-  ) -> Result<()>
+    keys: impl AsRef<Vec<String>>,
+  ) -> Result<String>
   {
-    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();
-    if detach
-    {
-      transaction.get_connection().execute(
-        templates::EdgeDeleteByNodes {
-          graph_name,
-          keys: &nodes_keys,
-        }
-        .render()?
-        .as_str(),
-        (),
-      )?;
-    }
-    else
-    {
-      let count = transaction.get_connection().query_row(
-        templates::EdgeCountForNode {
-          graph_name,
-          keys: &nodes_keys,
-        }
-        .render()?
-        .as_str(),
-        (),
-        |row| row.get::<_, usize>(0),
-      )?;
-      if count > 0
-      {
-        return Err(error::RunTimeError::DeleteConnectedNode.into());
+    Ok(
+      templates::EdgeCountForNode {
+        graph_name: graph_name.as_ref(),
+        keys: keys.as_ref(),
       }
-    }
-    transaction.get_connection().execute(
+      .render()?,
+    )
+  }
+
+  fn node_delete_query(graph_name: impl AsRef<str>, keys: impl AsRef<Vec<String>>)
+    -> Result<String>
+  {
+    Ok(
       templates::NodeDelete {
-        graph_name,
-        keys: &nodes_keys,
+        graph_name: graph_name.as_ref(),
+        keys: keys.as_ref(),
       }
-      .render()?
-      .as_str(),
-      (),
-    )?;
-    Ok(())
+      .render()?,
+    )
   }
-  fn update_node(
-    &self,
-    transaction: &mut Self::TransactionBox,
-    graph_name: impl AsRef<str>,
-    node: &crate::graph::Node,
-  ) -> Result<()>
+
+  fn node_update_query(graph_name: impl AsRef<str>) -> Result<String>
   {
-    transaction.get_connection().execute(
+    Ok(
       templates::NodeUpdate {
         graph_name: graph_name.as_ref(),
       }
-      .render()?
-      .as_str(),
-      named_params! {
-        ":key": PersistentKey(node.key()),
-        ":labels": serde_json::to_string(node.labels())?,
-        ":properties": serde_json::to_string(node.properties())?
-      },
-    )?;
-    Ok(())
+      .render()?,
+    )
   }
-  fn select_nodes(
-    &self,
-    transaction: &mut Self::TransactionBox,
+
+  fn node_select_query(
     graph_name: impl AsRef<str>,
-    query: store::SelectNodeQuery,
-  ) -> Result<Vec<crate::graph::Node>>
+    keys_var: Option<usize>,
+    labels_var: Option<usize>,
+    properties_var: Option<usize>,
+  ) -> Result<String>
   {
-    let mut prepared_query = transaction.get_connection().prepare(
+    Ok(
       templates::NodeSelect {
         graph_name: graph_name.as_ref(),
-        has_keys: query.keys.is_some(),
-        has_labels: query.labels.is_some(),
-        has_properties: query.properties.is_some(),
+        keys_var: &keys_var,
+        labels_var: &labels_var,
+        properties_var: &properties_var,
       }
-      .render()?
-      .as_str(),
-    )?;
-    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<_>>();
-      bindings.push((":keys", serde_json::to_string(&hex_keys)?));
-    }
-    if let Some(labels) = query.labels
-    {
-      bindings.push((":labels", serde_json::to_string(&labels)?));
-    }
-    if let Some(properties) = query.properties
-    {
-      bindings.push((":properties", serde_json::to_string(&properties)?));
-    }
-    let mut it = prepared_query.query(
-      bindings
-        .iter()
-        .map(|(k, v)| (*k, v as &dyn rusqlite::ToSql))
-        .collect::<Vec<_>>()
-        .as_slice(),
-    )?;
-    let mut nodes: Vec<graph::Node> = Default::default();
-    while let Some(row) = it.next()?
-    {
-      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::new(key, labels, properties));
-    }
-    Ok(nodes)
+      .render()?,
+    )
   }
-  fn create_edges<'a, T: IntoIterator<Item = &'a crate::graph::SinglePath>>(
-    &self,
-    transaction: &mut Self::TransactionBox,
-    graph_name: impl AsRef<str>,
-    edges_iter: T,
-  ) -> Result<()>
+
+  fn edge_create_query(graph_name: impl AsRef<str>) -> Result<String>
   {
-    for x in edges_iter
-    {
-      transaction.get_connection().execute(
-        templates::EdgeCreate {
-          graph_name: graph_name.as_ref(),
-        }
-        .render()?
-        .as_str(),
-        (
-          PersistentKey(x.key()),
-          serde_json::to_string(x.labels())?,
-          serde_json::to_string(x.properties())?,
-          PersistentKey(x.source().key()),
-          PersistentKey(x.destination().key()),
-        ),
-      )?;
-    }
-    Ok(())
+    Ok(
+      templates::EdgeCreate {
+        graph_name: graph_name.as_ref(),
+      }
+      .render()?,
+    )
   }
-  fn delete_edges(
-    &self,
-    transaction: &mut Self::TransactionBox,
-    graph_name: impl AsRef<str>,
-    query: store::SelectEdgeQuery,
-    directivity: crate::graph::EdgeDirectivity,
-  ) -> Result<()>
+  fn edge_delete_query(graph_name: impl AsRef<str>, keys: impl AsRef<Vec<String>>)
+    -> Result<String>
   {
-    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.path.key())).collect();
-    transaction.get_connection().execute(
+    Ok(
       templates::EdgeDelete {
-        graph_name,
-        keys: &edges_keys,
+        graph_name: graph_name.as_ref(),
+        keys: keys.as_ref(),
       }
-      .render()?
-      .as_str(),
-      (),
-    )?;
-    Ok(())
+      .render()?,
+    )
   }
-  fn update_edge(
-    &self,
-    transaction: &mut Self::TransactionBox,
-    graph_name: impl AsRef<str>,
-    edge: &crate::graph::Edge,
-  ) -> Result<()>
+  fn edge_update_query(graph_name: impl AsRef<str>) -> Result<String>
   {
-    transaction.get_connection().execute(
+    Ok(
       templates::EdgeUpdate {
         graph_name: graph_name.as_ref(),
       }
-      .render()?
-      .as_str(),
-      named_params! {
-        ":key": PersistentKey(edge.key().to_owned()),
-        ":labels": serde_json::to_string(edge.labels())?,
-        ":properties": serde_json::to_string(edge.properties())?
-      },
-    )?;
-    Ok(())
+      .render()?,
+    )
   }
-  fn select_edges(
-    &self,
-    transaction: &mut Self::TransactionBox,
+  fn edge_select_query(
     graph_name: impl AsRef<str>,
-    query: store::SelectEdgeQuery,
-    directivity: crate::graph::EdgeDirectivity,
-  ) -> Result<Vec<store::EdgeResult>>
+    is_undirected: bool,
+    table_suffix: impl AsRef<str>,
+    edge_keys_var: Option<usize>,
+    edge_labels_var: Option<usize>,
+    edge_properties_var: Option<usize>,
+    left_keys_var: Option<usize>,
+    left_labels_var: Option<usize>,
+    left_properties_var: Option<usize>,
+    right_keys_var: Option<usize>,
+    right_labels_var: Option<usize>,
+    right_properties_var: Option<usize>,
+  ) -> Result<String>
   {
-    if query.source.is_select_none() || query.destination.is_select_none()
-    {
-      return Ok(Default::default());
-    }
-    let (is_undirected, table_suffix) = match directivity
-    {
-      graph::EdgeDirectivity::Directed => (false, ""),
-      graph::EdgeDirectivity::Undirected => (true, "_undirected"),
-    };
-    let mut prepared_query = transaction.get_connection().prepare(
+    Ok(
       templates::EdgeSelect {
         graph_name: graph_name.as_ref(),
         is_undirected,
-        table_suffix,
-        has_edge_keys: query.keys.is_some(),
-        has_edge_labels: query.labels.is_some(),
-        has_edge_properties: query.properties.is_some(),
-        has_n_left_keys: query.source.keys.is_some(),
-        has_n_left_labels: query.source.labels.is_some(),
-        has_n_left_properties: query.source.properties.is_some(),
-        has_n_right_keys: query.destination.keys.is_some(),
-        has_n_right_labels: query.destination.labels.is_some(),
-        has_n_right_properties: query.destination.properties.is_some(),
-      }
-      .render()?
-      .as_str(),
-    )?;
-
-    let mut bindings = Vec::<(&'static str, String)>::new();
-
-    // Edge queries
-    if let Some(keys) = query.keys
-    {
-      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
-    {
-      bindings.push((":edge_labels", serde_json::to_string(&labels)?));
-    }
-    if let Some(properties) = query.properties
-    {
-      bindings.push((":edge_properties", serde_json::to_string(&properties)?));
-    }
-
-    // Left queries
-    if let Some(keys) = query.source.keys
-    {
-      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
-    {
-      bindings.push((":n_left_labels", serde_json::to_string(&labels)?));
-    }
-    if let Some(properties) = query.source.properties
-    {
-      bindings.push((":n_left_properties", serde_json::to_string(&properties)?));
-    }
-
-    // Right queries
-    if let Some(keys) = query.destination.keys
-    {
-      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
-    {
-      bindings.push((":n_right_labels", serde_json::to_string(&labels)?));
-    }
-    if let Some(properties) = query.destination.properties
-    {
-      bindings.push((":n_right_properties", serde_json::to_string(&properties)?));
-    }
-
-    // Execute query
-    let mut it = prepared_query.query(
-      bindings
-        .iter()
-        .map(|(k, v)| (*k, v as &dyn rusqlite::ToSql))
-        .collect::<Vec<_>>()
-        .as_slice(),
-    )?;
-
-    let mut edges: Vec<EdgeResult> = Default::default();
-    let mut edges_keys: HashSet<u128> = Default::default();
-    while let Some(row) = it.next()?
-    {
-      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())
-      {
-        continue;
+        table_suffix: table_suffix.as_ref(),
+        edge_keys_var,
+        edge_labels_var,
+        edge_properties_var,
+        left_keys_var,
+        left_labels_var,
+        left_properties_var,
+        right_keys_var,
+        right_labels_var,
+        right_properties_var,
       }
-      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)?)?;
-
-      let n_left_labels = serde_json::from_str(&row.get::<_, String>(5)?)?;
-      let n_left_properties = serde_json::from_str(&row.get::<_, String>(6)?)?;
-
-      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::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
-      {
-        (destination, source)
-      }
-      else
-      {
-        (source, destination)
-      };
-
-      edges.push(EdgeResult {
-        path: graph::Path::new(
-          edge_key.into(),
-          source,
-          edge_labels,
-          edge_properties,
-          destination,
-        ),
-        reversed,
-      });
-    }
-    Ok(edges)
+      .render()?,
+    )
   }
-  fn compute_statistics(&self, transaction: &mut Self::TransactionBox)
-    -> Result<store::Statistics>
+  fn compute_statistics_query(graph_name: impl AsRef<str>) -> Result<String>
   {
-    let (nodes_count, edges_count, labels_nodes_count, properties_count) =
-      transaction.get_connection().query_row(
-        templates::CallStats {
-          graph_name: "default",
-        }
-        .render()?
-        .as_str(),
-        (),
-        |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
-      )?;
-    Ok(store::Statistics {
-      nodes_count,
-      edges_count,
-      labels_nodes_count,
-      properties_count,
-    })
+    Ok(
+      templates::CallStats {
+        graph_name: graph_name.as_ref(),
+      }
+      .render()?,
+    )
   }
 }
 
 #[cfg(test)]
 mod tests
 {
-  use crate::{
-    prelude::*,
-    store::{Store, TransactionBoxable},
-  };
-  #[test]
-  fn test_hex()
-  {
-    assert_eq!(
-      super::hex(graph::Key::new(18580062510968287067562660977870108180)),
-      "0DFA63CEE7484B0DBFC407697F77F614"
-    );
-    assert_eq!(
-      super::hex(graph::Key::new(0)),
-      "00000000000000000000000000000000"
-    );
-  }
+  use crate::{prelude::*, store::TransactionBoxable};
   #[test]
   fn test_sqlite_metadata()
   {
     let temp_file = crate::tests::create_tmp_file();
     let store = super::Store::open(temp_file.path()).unwrap();
-    let mut tx = store.begin_read().unwrap();
+    let mut tx = store.begin_sql_read().unwrap();
     let version: utils::Version = store.get_metadata_value_json(&mut tx, "version").unwrap();
     assert_eq!(version.major, consts::GQLITE_VERSION.major);
     assert_eq!(version.minor, consts::GQLITE_VERSION.minor);
@@ -998,7 +696,7 @@ mod tests
 
     // Try to reopen
     let store = super::Store::open(temp_file.path()).unwrap();
-    let mut tx = store.begin_read().unwrap();
+    let mut tx = store.begin_sql_read().unwrap();
     let version: utils::Version = store.get_metadata_value_json(&mut tx, "version").unwrap();
     assert_eq!(version.major, consts::GQLITE_VERSION.major);
     assert_eq!(version.minor, consts::GQLITE_VERSION.minor);