gqlite 1.3.0 → 1.4.0

data/ext/gqlitedb/src/store/sqlbase/sqlmetadata.rs

@@ -0,0 +1,117 @@
+use serde::{Deserialize, Serialize};
+
+use super::{FromSqlValue, SqlValue};
+use crate::prelude::*;
+
+pub(crate) trait SqlMetaDataQueries
+{
+  fn metadata_get_query() -> Result<String>;
+  fn metadata_set_query() -> Result<String>;
+}
+
+pub(crate) trait SqlMetaDataStore: super::SqlStore
+{
+  /// Get the metavalue
+  fn get_optional_metadata_value<T: FromSqlValue>(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    key: impl Into<String>,
+  ) -> Result<Option<T>>;
+  fn get_metadata_value<T: FromSqlValue>(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    key: impl Into<String>,
+  ) -> Result<T>
+  {
+    let key = key.into();
+    self
+      .get_optional_metadata_value(transaction, &key)?
+      .ok_or_else(|| InternalError::MissingMetadata { key }.into())
+  }
+  #[allow(dead_code)]
+  fn get_metadata_value_or_else<T: FromSqlValue>(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    key: impl Into<String>,
+    f: impl FnOnce() -> T,
+  ) -> Result<T>
+  {
+    let v = self.get_optional_metadata_value(transaction, key)?;
+    Ok(v.unwrap_or_else(f))
+  }
+  /// Get the metadata value and deserialize it from JSON.
+  fn get_metadata_value_json<T: for<'a> Deserialize<'a>>(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    key: impl Into<String>,
+  ) -> Result<T>
+  {
+    Ok(serde_json::from_str(
+      &self.get_metadata_value::<String>(transaction, key)?,
+    )?)
+  }
+  #[allow(dead_code)]
+  fn get_metadata_value_json_or_else<T: for<'a> Deserialize<'a>>(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    key: impl Into<String>,
+    f: impl FnOnce() -> T,
+  ) -> Result<T>
+  {
+    let v = self.get_optional_metadata_value::<String>(transaction, key)?;
+    v.map_or_else(|| Ok(f()), |x| Ok(serde_json::from_str(&x)?))
+  }
+  fn set_metadata_value<'a>(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    key: impl Into<String>,
+    value: impl Into<SqlValue<'a>>,
+  ) -> Result<()>;
+  /// Serialize a value to JSON and store the result in the database.
+  fn set_metadata_value_json(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    key: impl Into<String>,
+    value: &impl Serialize,
+  ) -> Result<()>
+  {
+    self.set_metadata_value(transaction, key, &serde_json::to_string(value)?)
+  }
+}
+
+impl<TStore> SqlMetaDataStore for TStore
+where
+  TStore: super::SqlStore + SqlMetaDataQueries,
+{
+  fn get_optional_metadata_value<T: FromSqlValue>(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    key: impl Into<String>,
+  ) -> Result<Option<T>>
+  {
+    let mut res = None;
+    self.query_rows(
+      transaction,
+      Self::metadata_get_query()?,
+      (&key.into(),),
+      |x| {
+        res = Some(x.get(0)?);
+        Ok(())
+      },
+    )?;
+    Ok(res)
+  }
+  fn set_metadata_value<'a>(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    key: impl Into<String>,
+    value: impl Into<SqlValue<'a>>,
+  ) -> Result<()>
+  {
+    self.execute(
+      transaction,
+      Self::metadata_set_query()?,
+      (&key.into(), value.into()),
+    )
+  }
+}

data/ext/gqlitedb/src/store/sqlbase/sqlqueries.rs

@@ -0,0 +1,62 @@
+use crate::prelude::*;
+
+pub(crate) trait SqlQueries
+{
+  /// Query for creating a new graph.
+  fn graph_create_query(graph_name: impl AsRef<str>) -> Result<String>;
+  /// Query for deleting a  graph.
+  fn graph_delete(graph_name: impl AsRef<str>) -> Result<String>;
+  /// Query for creating a new node
+  fn node_create_query(graph_name: impl AsRef<str>) -> Result<String>;
+  /// Query for deleting the nodes.
+  fn node_delete_query(
+    graph_name: impl AsRef<str>,
+    keys: impl AsRef<Vec<String>>,
+  ) -> Result<String>;
+  /// Query for updating a node.
+  fn node_update_query(graph_name: impl AsRef<str>) -> Result<String>;
+  /// Query for selecting a node.
+  fn node_select_query(
+    graph_name: impl AsRef<str>,
+    keys_var: Option<usize>,
+    labels_var: Option<usize>,
+    properties_var: Option<usize>,
+  ) -> Result<String>;
+  /// Query for createing an edge.
+  fn edge_create_query(graph_name: impl AsRef<str>) -> Result<String>;
+  /// Query for deleting the edges.
+  fn edge_delete_query(
+    graph_name: impl AsRef<str>,
+    keys: impl AsRef<Vec<String>>,
+  ) -> Result<String>;
+  /// Query for updating a node.
+  fn edge_update_query(graph_name: impl AsRef<str>) -> Result<String>;
+  /// Query for deleting edges for the given nodes.
+  fn edge_delete_by_nodes_query(
+    graph_name: impl AsRef<str>,
+    keys: impl AsRef<Vec<String>>,
+  ) -> Result<String>;
+  /// Query for the number of edges connected to the nodes.
+  fn edge_count_for_nodes_query(
+    graph_name: impl AsRef<str>,
+    keys: impl AsRef<Vec<String>>,
+  ) -> Result<String>;
+  /// Query for selecting an edge.
+  #[allow(clippy::too_many_arguments)]
+  fn edge_select_query(
+    graph_name: impl AsRef<str>,
+    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>;
+  /// Query for computing statistics.
+  fn compute_statistics_query(graph_name: impl AsRef<str>) -> Result<String>;
+}

data/ext/gqlitedb/src/store/sqlbase/sqlstore.rs

@@ -0,0 +1,55 @@
+use crate::{prelude::*, store::TransactionBoxable};
+
+use super::{FromSqlValue, IntoBindings, SqlValue};
+
+pub(crate) trait Row: Sized
+{
+  fn get<T: FromSqlValue>(&self, index: usize) -> Result<T>
+  {
+    T::from_sql_value(self.get_value(index)?)
+  }
+  fn get_value(&self, index: usize) -> Result<SqlValue<'_>>;
+}
+
+/// Base trait for SQL Store.
+pub(crate) trait SqlStore
+{
+  type TransactionBox: TransactionBoxable;
+  type Row<'a>: Row;
+  /// Initialise an SQL store
+  fn initialise(&self) -> Result<()>;
+
+  /// Begin a read transaction.
+  fn begin_sql_read(&self) -> Result<Self::TransactionBox>;
+  /// Begin a write transaction.
+  fn begin_sql_write(&self) -> Result<Self::TransactionBox>;
+  /// Execute a batch of SQL queries for the given transaction.
+  fn execute_batch(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    sql: impl AsRef<str>,
+  ) -> Result<()>;
+  /// Execute a single SQL query for the given transaction.
+  fn execute<'a>(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    sql: impl AsRef<str>,
+    bindings: impl IntoBindings<'a>,
+  ) -> Result<()>;
+  /// Execute a SQL Query that return a single row.
+  fn query_row<'a, 'tx, T>(
+    &self,
+    transaction: &'tx mut Self::TransactionBox,
+    sql: impl AsRef<str>,
+    bindings: impl IntoBindings<'a>,
+    f: impl for<'b> FnOnce(&Self::Row<'b>) -> Result<T>,
+  ) -> Result<T>;
+  /// Execute a SQL Query that return multiple rows.
+  fn query_rows<'a, 'tx>(
+    &self,
+    transaction: &'tx mut Self::TransactionBox,
+    sql: impl AsRef<str>,
+    bindings: impl IntoBindings<'a>,
+    f: impl for<'b> FnMut(&Self::Row<'b>) -> Result<()>,
+  ) -> Result<()>;
+}

data/ext/gqlitedb/src/store/sqlbase/sqlvalue.rs

@@ -0,0 +1,189 @@
+use crate::prelude::*;
+
+#[derive(Debug)]
+pub(crate) enum SqlValue<'a>
+{
+  StringRef(&'a String),
+  String(String),
+  Key(&'a graph::Key),
+  Blob(&'a [u8]),
+  Text(&'a [u8]),
+  Float(f64),
+  Integer(i64),
+  Null,
+}
+
+impl<'a> From<&'a String> for SqlValue<'a>
+{
+  fn from(val: &'a String) -> Self
+  {
+    SqlValue::StringRef(val)
+  }
+}
+
+impl<'a> From<String> for SqlValue<'a>
+{
+  fn from(val: String) -> Self
+  {
+    SqlValue::String(val)
+  }
+}
+
+impl<'a> From<&'a graph::Key> for SqlValue<'a>
+{
+  fn from(val: &'a graph::Key) -> Self
+  {
+    SqlValue::Key(val)
+  }
+}
+
+pub(crate) trait IntoBindings<'a>
+{
+  fn into_bindings_iter(self) -> impl Iterator<Item = SqlValue<'a>>;
+}
+
+impl<'a> IntoBindings<'a> for ()
+{
+  fn into_bindings_iter(self) -> impl Iterator<Item = SqlValue<'a>>
+  {
+    vec![].into_iter()
+  }
+}
+
+impl<'a, T0> IntoBindings<'a> for (T0,)
+where
+  T0: Into<SqlValue<'a>>,
+{
+  fn into_bindings_iter(self) -> impl Iterator<Item = SqlValue<'a>>
+  {
+    vec![self.0.into()].into_iter()
+  }
+}
+
+impl<'a, T0, T1> IntoBindings<'a> for (T0, T1)
+where
+  T0: Into<SqlValue<'a>>,
+  T1: Into<SqlValue<'a>>,
+{
+  fn into_bindings_iter(self) -> impl Iterator<Item = SqlValue<'a>>
+  {
+    vec![self.0.into(), self.1.into()].into_iter()
+  }
+}
+
+impl<'a, T0, T1, T2> IntoBindings<'a> for (T0, T1, T2)
+where
+  T0: Into<SqlValue<'a>>,
+  T1: Into<SqlValue<'a>>,
+  T2: Into<SqlValue<'a>>,
+{
+  fn into_bindings_iter(self) -> impl Iterator<Item = SqlValue<'a>>
+  {
+    vec![self.0.into(), self.1.into(), self.2.into()].into_iter()
+  }
+}
+
+impl<'a, T0, T1, T2, T3, T4> IntoBindings<'a> for (T0, T1, T2, T3, T4)
+where
+  T0: Into<SqlValue<'a>>,
+  T1: Into<SqlValue<'a>>,
+  T2: Into<SqlValue<'a>>,
+  T3: Into<SqlValue<'a>>,
+  T4: Into<SqlValue<'a>>,
+{
+  fn into_bindings_iter(self) -> impl Iterator<Item = SqlValue<'a>>
+  {
+    vec![
+      self.0.into(),
+      self.1.into(),
+      self.2.into(),
+      self.3.into(),
+      self.4.into(),
+    ]
+    .into_iter()
+  }
+}
+
+impl<'a> IntoBindings<'a> for Vec<SqlValue<'a>>
+{
+  fn into_bindings_iter(self) -> impl Iterator<Item = SqlValue<'a>>
+  {
+    self.into_iter()
+  }
+}
+
+pub(crate) trait FromSqlValue: Sized
+{
+  fn from_sql_value<'a>(value: SqlValue<'a>) -> Result<Self>;
+}
+
+impl FromSqlValue for String
+{
+  fn from_sql_value<'a>(value: SqlValue<'a>) -> Result<Self>
+  {
+    match value
+    {
+      SqlValue::Text(text) => Ok(std::str::from_utf8(text)?.to_string()),
+      SqlValue::String(string) => Ok(string),
+      SqlValue::StringRef(string) => Ok(string.clone()),
+      _ =>
+      {
+        println!("{:?} to string", value);
+        Err(InternalError::InvalidQueryResultCast.into())
+      }
+    }
+  }
+}
+
+impl FromSqlValue for usize
+{
+  fn from_sql_value<'a>(value: SqlValue<'a>) -> Result<Self>
+  {
+    match value
+    {
+      SqlValue::Integer(i) => Ok(i as usize),
+      _ =>
+      {
+        println!("{:?} to usize", value);
+        Err(InternalError::InvalidQueryResultCast.into())
+      }
+    }
+  }
+}
+
+impl FromSqlValue for u32
+{
+  fn from_sql_value<'a>(value: SqlValue<'a>) -> Result<Self>
+  {
+    match value
+    {
+      SqlValue::Integer(i) => Ok(i as u32),
+      _ =>
+      {
+        println!("{:?} to u32", value);
+        Err(InternalError::InvalidQueryResultCast.into())
+      }
+    }
+  }
+}
+
+impl FromSqlValue for graph::Key
+{
+  fn from_sql_value<'a>(value: SqlValue<'a>) -> Result<Self>
+  {
+    match value
+    {
+      SqlValue::Integer(i) => Ok(graphcore::Key::new(i as u128)),
+      SqlValue::Key(k) => Ok(*k),
+      SqlValue::Blob(b) => <[u8; 16]>::try_from(b)
+        .map(u128::from_be_bytes)
+        .map(graphcore::Key::new)
+        .map_err(|_| InternalError::InvalidQueryResultCast.into()),
+      _ =>
+      {
+        println!("{:?} to key", value);
+        Err(InternalError::InvalidQueryResultCast.into())
+      }
+    }
+  }
+}