gqlite 1.3.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38e53ea482654edda2dec42d18ba7aff7e5660f5643f80f66dfd966e21415ebd
-  data.tar.gz: ce0cb6a21adbca63605e86d753a3c20f281a2126601c5225c446d161efe97094
+  metadata.gz: 1b7eba40745af114ff57ca358b2e03c67a7adb9717ad7c7b81ddd7444503fbb1
+  data.tar.gz: 3ae6e7c7b038a2caeaf728ff7ce98c49266160d181f478c8259b98d7d8157ba5
 SHA512:
-  metadata.gz: f1b60e9c256da4300381ef244158ea61a464529e7518dfe1ee532c0e5ada468860ea08a5c0ab91304b00b5e09590774131fd7487d0bb79d2435d7c13009bd0e6
-  data.tar.gz: 4009f247ebcdc9519bfa40853b5ab8b32ab3c53fd365cf6f9dd3a25e395596dc70a2c12f7e795496695d8227428f37edfb1375cbcc59ac35e71a76ba973bd318
+  metadata.gz: 6674d35ca4d0ec02090ef1521f9f8bb2a4025a050ed312e9c20d50033c8a3472a6a31bdb73dfe6fa9ec99612518c5f5edd72d3ea9d8ead7885c39ed106ac6056
+  data.tar.gz: e200b7d2a4203cf803a65bcd6eef82a990fc8c1fa2e2846148673109731353898dacd7b388fe23c9c5b8e5eeae2b56768912408f6f916805111d322c0a83d5ac

data/ext/Cargo.toml

@@ -3,15 +3,15 @@ resolver = "2"
 members = ["gqliterb", "gqlitedb", "graphcore"]
 
 [workspace.package]
-version = "0.6.0"
+version = "0.7.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://gqlite.org"
 repository = "https://gitlab.com/gqlite/gqlite"
 
 [workspace.dependencies]
-graphcore = { version = "0.2.0", path = "graphcore" }
-gqlitedb = { version = "0.6.0", path = "gqlitedb" }
+graphcore = { version = "0.7.0", path = "graphcore" }
+gqlitedb = { version = "0.7.0", path = "gqlitedb" }
 
 askama = { version = "0.14" }
 ccutils = { version = "0.4" }

data/ext/gqlitedb/Cargo.toml

@@ -16,12 +16,13 @@ default = ["redb", "capi", "sqlite"]
 _backtrace = []
 capi = []
 redb = ["dep:redb", "dep:redb2"]
-_pgql = ["dep:pgrx"]
+_pgrx = ["dep:pgrx"]
 _pg13 = ["pgrx/pg13"]
 _pg14 = ["pgrx/pg14"]
 _pg15 = ["pgrx/pg15"]
 _pg16 = ["pgrx/pg16"]
 _pg17 = ["pgrx/pg17"]
+postgres = ["dep:postgres"]
 sqlite = ["dep:rusqlite", "dep:askama"]
 _value_private = []
 bundled = ["rusqlite/bundled"]
@@ -33,9 +34,10 @@ askama = { workspace = true, optional = true }
 ccutils = { workspace = true, features = ["alias", "pool", "sync"] }
 ciborium = "0.2"
 itertools = { workspace = true }
-pgrx = { version = "0.16", optional = true }
 pest = "2"
 pest_derive = "2"
+pgrx = { version = "0.16", optional = true }
+postgres = { version = "0.19", optional = true }
 rand = "0.9"
 redb = { version = "3", optional = true }
 redb2 = { version = "2", optional = true, package = "redb" }
@@ -52,6 +54,7 @@ uuid = { workspace = true }
 ccutils = { workspace = true, features = ["alias", "temporary"] }
 divan = "0.1"
 iai-callgrind = { version = "0.16" }
+pgtemp = "0.6"
 regex = "1"
 
 # web:

data/ext/gqlitedb/src/aggregators/arithmetic.rs

@@ -46,6 +46,7 @@ where
       | Value::Edge(..)
       | Value::Array(..)
       | Value::String(..)
+      | Value::TimeStamp(..)
       | Value::Map(..)
       | Value::Path(..) => Err(RunTimeError::InvalidBinaryOperands)?,
       Value::Null =>

data/ext/gqlitedb/src/compiler/expression_analyser.rs

@@ -21,6 +21,7 @@ pub(crate) enum ExpressionType
   Float,
   Path,
   String,
+  TimeStamp,
   Variant,
 }
 
@@ -419,6 +420,7 @@ impl<'b> Analyser<'b>
           value::Value::Map(_) => ExpressionType::Map,
           value::Value::Path(_) => ExpressionType::Path,
           value::Value::String(_) => ExpressionType::String,
+          value::Value::TimeStamp(_) => ExpressionType::TimeStamp,
         },
         true,
         false,

data/ext/gqlitedb/src/compiler.rs

@@ -942,6 +942,7 @@ pub(crate) fn compile(
       {
         ast::Statement::CreateGraph(create_graph) => Ok(Block::CreateGraph {
           name: create_graph.name.to_owned(),
+          if_not_exists: create_graph.if_not_exists,
         }),
         ast::Statement::DropGraph(drop_graph) => Ok(Block::DropGraph {
           name: drop_graph.name.to_owned(),

data/ext/gqlitedb/src/connection.rs

@@ -8,12 +8,15 @@ pub enum Backend
 {
   /// Select the first available backend.
   Automatic,
-  /// SQLite backend.
-  #[cfg(feature = "sqlite")]
-  SQLite,
+  /// Postgres backend.
+  #[cfg(feature = "postgres")]
+  Postgres,
   /// Redb backend.
   #[cfg(feature = "redb")]
   Redb,
+  /// SQLite backend.
+  #[cfg(feature = "sqlite")]
+  SQLite,
 }
 
 /// Builder with high-level API for creating connection.
@@ -52,16 +55,21 @@ impl ConnectionBuilder
       {
         self.map.insert(key, "automatic".into());
       }
-      #[cfg(feature = "sqlite")]
-      Backend::SQLite =>
+      #[cfg(feature = "postgres")]
+      Backend::Postgres =>
       {
-        self.map.insert(key, "sqlite".into());
+        self.map.insert(key, "postgres".into());
       }
       #[cfg(feature = "redb")]
       Backend::Redb =>
       {
         self.map.insert(key, "redb".into());
       }
+      #[cfg(feature = "sqlite")]
+      Backend::SQLite =>
+      {
+        self.map.insert(key, "sqlite".into());
+      }
     }
     self
   }
@@ -204,7 +212,7 @@ impl Connection
 
             sq_r.map_err(|rb_e| {
               StoreError::OpeningError {
-                errors: error::vec_to_error(&vec![sq_e, rb_e]),
+                errors: error::vec_to_error(&[sq_e, rb_e]),
               }
               .into()
             })
@@ -251,6 +259,33 @@ impl Connection
           .boxed(),
         })
       }
+      #[cfg(feature = "postgres")]
+      "postgres" =>
+      {
+        let mut config = postgres::Config::new();
+        if let Some(host) = options.get("host")
+        {
+          let host: &String = host.try_into_ref()?;
+          config.host(host);
+        }
+        if let Some(user) = options.get("user")
+        {
+          let user: &String = user.try_into_ref()?;
+          config.user(user);
+        }
+        if let Some(password) = options.get("password")
+        {
+          let password: &String = password.try_into_ref()?;
+          config.password(password);
+        }
+        let store = store::postgres::Store::connect(config)?;
+        Ok(Connection {
+          connection: ConnectionImpl {
+            store,
+            function_manager: functions::Manager::new(),
+          },
+        })
+      }
       _ => Err(StoreError::UnknownBackend { backend }.into()),
     }
   }

data/ext/gqlitedb/src/error.rs

@@ -313,6 +313,8 @@ pub enum InternalError
   Poison(String),
   #[error("IOError: {0}.")]
   IOError(#[from] std::io::Error),
+  #[error("Utf8Error: {0}.")]
+  Utf8Error(#[from] std::str::Utf8Error),
 }
 
 /// Error in the store backend.
@@ -541,6 +543,7 @@ error_as_internal! {ciborium::ser::Error<std::io::Error>}
 error_as_internal! {ciborium::de::Error<std::io::Error>}
 error_as_internal! {serde_json::Error}
 error_as_internal! {std::num::ParseFloatError}
+error_as_internal! {std::str::Utf8Error}
 
 #[cfg(feature = "redb")]
 mod _trait_impl_redb

data/ext/gqlitedb/src/interpreter/evaluators.rs

@@ -1212,10 +1212,13 @@ pub(crate) fn eval_program<TStore: store::Store>(
     }
     match block
     {
-      instructions::Block::CreateGraph { name } =>
+      instructions::Block::CreateGraph {
+        name,
+        if_not_exists,
+      } =>
       {
         store
-          .create_graph(&mut tx, name, false)
+          .create_graph(&mut tx, name, *if_not_exists)
           .map_err(|e|
             error::map_error!(e, Error::StoreError(StoreError::DuplicatedGraph { graph_name }) => RunTimeError::DuplicatedGraph {
               graph_name: graph_name.clone(),

data/ext/gqlitedb/src/interpreter/instructions.rs

@@ -207,7 +207,7 @@ pub(crate) enum Block
 {
   CreateGraph
   {
-    name: String
+    name: String, if_not_exists: bool
   },
   DropGraph
   {

data/ext/gqlitedb/src/lib.rs

@@ -35,7 +35,7 @@ pub use {
   error::{CompileTimeError, Error, RunTimeError, StoreError},
   graph::{labels, Edge, Node, Path},
   query_result::QueryResult,
-  value::{array, value_map, Value, ValueMap, ValueTryIntoRef},
+  value::{array, value_map, TimeStamp, Value, ValueMap, ValueTryIntoRef},
 };
 
 pub use graphcore::{table, Table};

data/ext/gqlitedb/src/parser/ast.rs

@@ -129,6 +129,7 @@ pub(crate) type Queries = Vec<Statements>;
 pub(crate) struct CreateGraph
 {
   pub(crate) name: String,
+  pub(crate) if_not_exists: bool,
 }
 
 #[derive(Debug)]

data/ext/gqlitedb/src/parser/gql.pest

@@ -63,7 +63,8 @@ where_modifier = { "WHERE" ~ expression }
 
 // Statements
 statement = {
-    create_graph_statement
+    create_graph_if_not_exists_statement
+  | create_graph_statement
   | drop_graph_if_exists_statement
   | drop_graph_statement
   | use_graph_statement
@@ -83,6 +84,7 @@ statement = {
 star = { "*" }
 
 create_graph_statement   = { "CREATE" ~ "GRAPH" ~ ident }
+create_graph_if_not_exists_statement   = { "CREATE" ~ "GRAPH" ~ "IF" ~ "NOT" ~ "EXISTS" ~ ident }
 drop_graph_statement     = { "DROP" ~ "GRAPH" ~ ident }
 drop_graph_if_exists_statement     = { "DROP" ~ "GRAPH" ~ "IF" ~ "EXISTS" ~ ident }
 use_graph_statement      = { "USE" ~ ident }

data/ext/gqlitedb/src/parser/parser_impl.rs

@@ -909,7 +909,15 @@ impl AstBuilder
     {
       Rule::create_graph_statement => Ok(ast::Statement::CreateGraph(ast::CreateGraph {
         name: self.build_ident(&mut pair.into_inner())?,
+        if_not_exists: false,
       })),
+      Rule::create_graph_if_not_exists_statement =>
+      {
+        Ok(ast::Statement::CreateGraph(ast::CreateGraph {
+          name: self.build_ident(&mut pair.into_inner())?,
+          if_not_exists: true,
+        }))
+      }
       Rule::drop_graph_statement => Ok(ast::Statement::DropGraph(ast::DropGraph {
         name: self.build_ident(&mut pair.into_inner())?,
         if_exists: false,

data/ext/gqlitedb/src/prelude.rs

@@ -7,3 +7,6 @@ pub(crate) use crate::{
 };
 
 pub(crate) use error::export::Error as ErrorType;
+
+#[cfg(any(feature = "sqlite", feature = "postgres", feature = "_pgrx"))]
+pub(crate) use store::sqlbase::{self, Row as _, SqlMetaDataStore as _, SqlStore as _};

data/ext/gqlitedb/src/store/{pgql.rs → pgrx.rs}

@@ -1,5 +1,7 @@
 use crate::{graph, Result};
 
+impl SqlParams for &[&(dyn tokio_postgres::types::ToSql + Sync)] {}
+
 //  _____                               _   _
 // |_   _| __ __ _ _ __  ___  __ _  ___| |_(_) ___  _ __
 //   | || '__/ _` | '_ \/ __|/ _` |/ __| __| |/ _ \| '_ \

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<()>;
+}