gqlite 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8b19f14f03ff7f92bf78f132e0c26f800e2d9ce3be108557bb9d23c11e0e8d1
-  data.tar.gz: aad435a97e100195806af926765c90f6c57d1232c51afe771d2b89f00ffa2ea2
+  metadata.gz: 1b7eba40745af114ff57ca358b2e03c67a7adb9717ad7c7b81ddd7444503fbb1
+  data.tar.gz: 3ae6e7c7b038a2caeaf728ff7ce98c49266160d181f478c8259b98d7d8157ba5
 SHA512:
-  metadata.gz: fe9d202a5b338e34141df0240867a68b4f794067dc506d173264a66decd973029dc04f64da9f0a1f6192da8cab652e8c71e8c63a1432c4110259d971d64d3697
-  data.tar.gz: 6f90979086a3be82858d38b62bc23a84ab8a05266ca048541d59c87d5f43757219e88c8a2d7c158762e19533e17720f2d5b583d24d8614a6bbef9196374b6004
+  metadata.gz: 6674d35ca4d0ec02090ef1521f9f8bb2a4025a050ed312e9c20d50033c8a3472a6a31bdb73dfe6fa9ec99612518c5f5edd72d3ea9d8ead7885c39ed106ac6056
+  data.tar.gz: e200b7d2a4203cf803a65bcd6eef82a990fc8c1fa2e2846148673109731353898dacd7b388fe23c9c5b8e5eeae2b56768912408f6f916805111d322c0a83d5ac

data/ext/Cargo.toml

@@ -3,17 +3,18 @@ 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" }
 itertools = "0.14"
 serde = "1"
 thiserror = "2"

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"]
@@ -30,12 +31,13 @@ bundled = ["rusqlite/bundled"]
 graphcore = { workspace = true }
 
 askama = { workspace = true, optional = true }
-ccutils = { version = "0.4", features = ["alias", "pool", "sync"] }
+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" }
@@ -49,9 +51,10 @@ thiserror = { workspace = true }
 uuid = { workspace = true }
 
 [dev-dependencies]
-ccutils = { version = "0.4", features = ["alias", "temporary"] }
+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

@@ -19,6 +19,14 @@ macro_rules! compile_binary_op {
   };
 }
 
+struct CompiledReturnWith
+{
+  variables: Vec<(String, RWExpression)>,
+  filter: Instructions,
+  modifiers: Modifiers,
+  variables_sizes: VariablesSizes,
+}
+
 struct Compiler
 {
   function_manager: functions::Manager,
@@ -701,19 +709,13 @@ impl Compiler
     })
   }
 
-  #[allow(clippy::type_complexity)]
   fn compile_return_with(
     &mut self,
     all: bool,
     expressions: &[ast::NamedExpression],
     where_expression: &Option<ast::Expression>,
     modifiers: &ast::Modifiers,
-  ) -> Result<(
-    Vec<(String, RWExpression)>,
-    Instructions,
-    Modifiers,
-    VariablesSizes,
-  )>
+  ) -> Result<CompiledReturnWith>
   {
     let mut variables = Vec::<(ast::VariableIdentifier, RWExpression)>::new();
     let mut filter = Default::default();
@@ -775,7 +777,7 @@ impl Compiler
     }
 
     let modifiers = self.compile_modifiers(modifiers)?;
-    let variables_size = self.variables_size();
+    let variables_sizes = self.variables_size();
     self
       .variables_manager
       .keep_variables(variables.iter().map(|(n, _)| n))?;
@@ -784,7 +786,12 @@ impl Compiler
       .into_iter()
       .map(|(var_id, e)| (var_id.take_name(), e))
       .collect();
-    Ok((variables, filter, modifiers, variables_size))
+    Ok(CompiledReturnWith {
+      variables,
+      filter,
+      modifiers,
+      variables_sizes,
+    })
   }
 
   fn compile_match_patterns(
@@ -935,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(),
@@ -951,17 +959,17 @@ pub(crate) fn compile(
         ),
         ast::Statement::Return(return_statement) =>
         {
-          let (variables, filter, modifiers, variables_size) = compiler.compile_return_with(
+          let compiled_return_with = compiler.compile_return_with(
             return_statement.all,
             &return_statement.expressions,
             &return_statement.where_expression,
             &return_statement.modifiers,
           )?;
           Ok(Block::Return {
-            variables,
-            filter,
-            modifiers,
-            variables_size,
+            variables: compiled_return_with.variables,
+            filter: compiled_return_with.filter,
+            modifiers: compiled_return_with.modifiers,
+            variables_sizes: compiled_return_with.variables_sizes,
           })
         }
         ast::Statement::Call(call) =>
@@ -978,17 +986,21 @@ pub(crate) fn compile(
         }
         ast::Statement::With(with) =>
         {
-          let (variables, filter, modifiers, variables_size) = compiler.compile_return_with(
+          let compiled_return_with = compiler.compile_return_with(
             with.all,
             &with.expressions,
             &with.where_expression,
             &with.modifiers,
           )?;
           Ok(Block::With {
-            variables: variables.into_iter().map(|(_, v)| v).collect(),
-            filter,
-            modifiers,
-            variables_size,
+            variables: compiled_return_with
+              .variables
+              .into_iter()
+              .map(|(_, v)| v)
+              .collect(),
+            filter: compiled_return_with.filter,
+            modifiers: compiled_return_with.modifiers,
+            variables_sizes: compiled_return_with.variables_sizes,
           })
         }
         ast::Statement::Unwind(unwind) =>

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/functions/containers.rs

@@ -74,7 +74,7 @@ impl super::FunctionTrait for Size
   {
     let container = arguments
       .first()
-      .ok_or_else(|| RunTimeError::InvalidNumberOfArguments {
+      .ok_or(RunTimeError::InvalidNumberOfArguments {
         function_name: "size",
         got: arguments.len(),
         expected: 1,

data/ext/gqlitedb/src/functions/path.rs

@@ -10,7 +10,7 @@ impl super::FunctionTrait for Length
   {
     let container = arguments
       .first()
-      .ok_or_else(|| RunTimeError::InvalidNumberOfArguments {
+      .ok_or(RunTimeError::InvalidNumberOfArguments {
         function_name: "length",
         got: arguments.len(),
         expected: 1,

data/ext/gqlitedb/src/functions/scalar.rs

@@ -32,6 +32,29 @@ impl super::FunctionTrait for Coalesce
 
 super::declare_function!(coalesce, Coalesce, custom_trait);
 
+#[derive(Debug, Default)]
+pub(super) struct Id {}
+
+impl Id
+{
+  fn call_impl(value: &value::Value) -> FResult<graph::Key>
+  {
+    match value
+    {
+      value::Value::Node(n) => Ok(n.key()),
+      value::Value::Edge(e) => Ok(e.key()),
+      _ => Err(RunTimeError::InvalidArgument {
+        function_name: "id",
+        index: 0,
+        expected_type: "node or edge",
+        value: format!("{:?}", value),
+      }),
+    }
+  }
+}
+
+super::declare_function!(id, Id, call_impl(crate::value::Value) -> graph::Key);
+
 #[derive(Debug, Default)]
 pub(super) struct ToInteger {}
 

data/ext/gqlitedb/src/functions.rs

@@ -59,6 +59,13 @@ impl FunctionTypeTrait for f64
   }
 }
 
+impl FunctionTypeTrait for graph::Key
+{
+  fn result_type() -> ExpressionType
+  {
+    ExpressionType::Key
+  }
+}
 impl<T> FunctionTypeTrait for Vec<T>
 {
   fn result_type() -> ExpressionType
@@ -146,6 +153,7 @@ impl Manager
           path::Nodes::create(),
           path::Edges::create(),
           scalar::Coalesce::create(),
+          scalar::Id::create(),
           scalar::Properties::create(),
           scalar::ToInteger::create(),
           string::ToString::create(),

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

@@ -950,7 +950,6 @@ fn compute_return_with_table(
     for row in input_table.into_row_iter()
     {
       // a) compute non-aggregated columns
-      let mut row = row.extended(variables_sizes.total_size())?;
       let out_row = variables
         .iter()
         .map(|rw_expr| {
@@ -959,9 +958,7 @@ fn compute_return_with_table(
             assert_eq!(rw_expr.aggregations.len(), 0);
             let mut stack = Stack::default();
             eval_instructions(&mut stack, &row, &rw_expr.instructions, parameters)?;
-            let value: value::Value = stack.try_pop_into()?;
-            row.set(rw_expr.col_id, value.to_owned())?;
-            Ok(value)
+            stack.try_pop_into()
           }
           else
           {
@@ -1039,12 +1036,12 @@ fn compute_return_with_table(
     output_table = input_table
       .into_row_iter()
       .map(|row| {
-        let mut out_row = row.extended(variables_sizes.total_size())?;
+        let mut out_row = row.clone().extended(variables_sizes.total_size())?;
         for rw_expr in variables.iter()
         {
           assert_eq!(rw_expr.aggregations.len(), 0);
           let mut stack = Stack::default();
-          eval_instructions(&mut stack, &out_row, &rw_expr.instructions, parameters)?;
+          eval_instructions(&mut stack, &row, &rw_expr.instructions, parameters)?;
           let value: value::Value = stack.try_pop_into()?;
           out_row.set(rw_expr.col_id, value.to_owned())?;
         }
@@ -1215,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(),
@@ -1429,7 +1429,7 @@ pub(crate) fn eval_program<TStore: store::Store>(
         variables,
         filter,
         modifiers,
-        variables_size,
+        variables_sizes: variables_size,
       } =>
       {
         let (names, variables): (Vec<_>, Vec<_>) = variables.iter().map(|(s, e)| (s, e)).unzip();
@@ -1454,7 +1454,7 @@ pub(crate) fn eval_program<TStore: store::Store>(
         variables,
         filter,
         modifiers,
-        variables_size,
+        variables_sizes: variables_size,
       } =>
       {
         input_table = compute_return_with_table(

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
   {
@@ -234,7 +234,7 @@ pub(crate) enum Block
     variables: Vec<(String, RWExpression)>,
     filter: Instructions,
     modifiers: Modifiers,
-    variables_size: VariablesSizes,
+    variables_sizes: VariablesSizes,
   },
   Call
   {
@@ -247,7 +247,7 @@ pub(crate) enum Block
     variables: Vec<RWExpression>,
     filter: Instructions,
     modifiers: Modifiers,
-    variables_size: VariablesSizes,
+    variables_sizes: VariablesSizes,
   },
   Unwind
   {

data/ext/gqlitedb/src/lib.rs

@@ -7,9 +7,7 @@
 //! for an example of use.
 
 #![warn(missing_docs)]
-#![deny(warnings)]
 #![allow(clippy::result_large_err)]
-#![allow(clippy::unnecessary_lazy_evaluations)]
 
 mod aggregators;
 #[cfg(feature = "capi")]
@@ -37,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)] {}
+
 //  _____                               _   _
 // |_   _| __ __ _ _ __  ___  __ _  ___| |_(_) ___  _ __
 //   | || '__/ _` | '_ \/ __|/ _` |/ __| __| |/ _ \| '_ \