gqlite 1.2.3 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4f3b9b41902b916ad1893fce53201a6e98b58f9cc20fa66a1f13849f3e84536
-  data.tar.gz: 7dfdb9ac4f71b24332916940e145fbfd513c3be5bcb627575d749825afab88fe
+  metadata.gz: 38e53ea482654edda2dec42d18ba7aff7e5660f5643f80f66dfd966e21415ebd
+  data.tar.gz: ce0cb6a21adbca63605e86d753a3c20f281a2126601c5225c446d161efe97094
 SHA512:
-  metadata.gz: 6d0258dd0e102cc62c193f0ad44e6fe028576be9b879686d8a5feb03bec6c2baefffc4bc4c2db8de3c43fa82eb48622386010c5b287fbb5efdeb92905578e9b9
-  data.tar.gz: f18708c7479c61a90c05b1acb17aa9dc951a608e7225342658c678adb8106a0215b28496a7accb47c58fd78448e5db5b03e735b81b67b83d42653094ffd4b19c
+  metadata.gz: f1b60e9c256da4300381ef244158ea61a464529e7518dfe1ee532c0e5ada468860ea08a5c0ab91304b00b5e09590774131fd7487d0bb79d2435d7c13009bd0e6
+  data.tar.gz: 4009f247ebcdc9519bfa40853b5ab8b32ab3c53fd365cf6f9dd3a25e395596dc70a2c12f7e795496695d8227428f37edfb1375cbcc59ac35e71a76ba973bd318

data/ext/Cargo.toml

@@ -0,0 +1,21 @@
+[workspace]
+resolver = "2"
+members = ["gqliterb", "gqlitedb", "graphcore"]
+
+[workspace.package]
+version = "0.6.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" }
+
+askama = { version = "0.14" }
+ccutils = { version = "0.4" }
+itertools = "0.14"
+serde = "1"
+thiserror = "2"
+uuid = { version = "1", features = ["v4"] }

data/ext/gqlitedb/Cargo.toml

@@ -0,0 +1,77 @@
+[package]
+name = "gqlitedb"
+description = "GQLite is a Rust-language library, with a C interface, that implements a small, fast, self-contained, high-reliability, full-featured, Graph Query database engine."
+readme = "../../README.md"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+homepage.workspace = true
+repository.workspace = true
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[features]
+default = ["redb", "capi", "sqlite"]
+_backtrace = []
+capi = []
+redb = ["dep:redb", "dep:redb2"]
+_pgql = ["dep:pgrx"]
+_pg13 = ["pgrx/pg13"]
+_pg14 = ["pgrx/pg14"]
+_pg15 = ["pgrx/pg15"]
+_pg16 = ["pgrx/pg16"]
+_pg17 = ["pgrx/pg17"]
+sqlite = ["dep:rusqlite", "dep:askama"]
+_value_private = []
+bundled = ["rusqlite/bundled"]
+
+[dependencies]
+graphcore = { workspace = true }
+
+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"
+rand = "0.9"
+redb = { version = "3", optional = true }
+redb2 = { version = "2", optional = true, package = "redb" }
+rusqlite = { package = "rusqlite", version = "0.37", optional = true, features = [
+  "functions",
+  "uuid",
+] }
+serde = { workspace = true }
+serde_json = "1"
+thiserror = { workspace = true }
+uuid = { workspace = true }
+
+[dev-dependencies]
+ccutils = { workspace = true, features = ["alias", "temporary"] }
+divan = "0.1"
+iai-callgrind = { version = "0.16" }
+regex = "1"
+
+# web:
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+# rusqlite_wasm = { package = "rusqlite", version = "0.37", optional = true, git = "https://github.com/Spxg/rusqlite.git", branch = "wasm-demo", features = [
+#   "functions",
+#   "uuid",
+# ] }
+uuid = { version = "1", features = ["js"] }
+
+# [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+# rusqlite_main = { package = "rusqlite", version = "0.37", optional = true, features = [
+#   "functions",
+#   "uuid",
+# ] }
+
+[[bench]]
+name = "pokec_divan"
+harness = false
+
+[[bench]]
+name = "pokec_iai"
+harness = false

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/benches/common/pokec.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashSet, fs};
 
 use ccutils::temporary::TemporaryFile;
-use gqlitedb::{map, Connection};
+use gqlitedb::{value_map, Connection};
 use rand::{seq::IndexedRandom, Rng};
 use regex::Regex;
 
@@ -24,11 +24,21 @@ impl Pokec
 {
   pub(crate) fn load(backend: &str, size: PokecSize) -> Pokec
   {
+    let backend = match backend
+    {
+      "sqlite" => gqlitedb::Backend::SQLite,
+      "redb" => gqlitedb::Backend::Redb,
+      o => panic!("Unknown backend '{}'", o),
+    };
     let temporary_file = TemporaryFile::builder()
       .should_create_file(false)
       .label("gqlite_bench")
       .create();
-    let connection = Connection::open(temporary_file.path(), map!("backend" => backend)).unwrap();
+    let connection = Connection::builder()
+      .path(temporary_file.path())
+      .backend(backend)
+      .create()
+      .unwrap();
 
     let filename = match size
     {
@@ -39,7 +49,7 @@ impl Pokec
     let import_query = fs::read_to_string(filename).unwrap();
 
     connection
-      .execute_query(import_query, Default::default())
+      .execute_oc_query(import_query, Default::default())
       .unwrap();
     Self {
       temporary_file,
@@ -71,9 +81,9 @@ impl Pokec
     let random_id = self.ids.choose(rng).unwrap();
     self
       .connection
-      .execute_query(
+      .execute_oc_query(
         "MATCH (n:User {id: $id}) RETURN n",
-        map!("$id" => *random_id),
+        value_map!("$id" => *random_id),
       )
       .unwrap();
   }
@@ -84,9 +94,9 @@ impl Pokec
     let random_id = self.ids.choose(rng).unwrap();
     self
       .connection
-      .execute_query(
+      .execute_oc_query(
         "MATCH (n:User) WHERE n.id = $id RETURN n",
-        map!("$id" => *random_id),
+        value_map!("$id" => *random_id),
       )
       .unwrap();
   }
@@ -97,9 +107,9 @@ impl Pokec
     let random_id = self.ids.choose(rng).unwrap();
     self
       .connection
-      .execute_query(
+      .execute_oc_query(
         "MATCH (s:User {id: $id})-->(n:User) RETURN n.id",
-        map!("$id" => *random_id),
+        value_map!("$id" => *random_id),
       )
       .unwrap();
   }
@@ -110,9 +120,9 @@ impl Pokec
     let random_id = self.ids.choose(rng).unwrap();
     self
       .connection
-      .execute_query(
+      .execute_oc_query(
         "MATCH (s:User {id: $id})-->(n:User) WHERE n.age >= 18 RETURN n.id",
-        map!("$id" => *random_id),
+        value_map!("$id" => *random_id),
       )
       .unwrap();
   }
@@ -123,9 +133,9 @@ impl Pokec
     let random_id = self.ids.choose(rng).unwrap();
     self
       .connection
-      .execute_query(
+      .execute_oc_query(
         "MATCH (s:User {id: $id})-->()-->(n:User) RETURN n.id",
-        map!("$id" => *random_id),
+        value_map!("$id" => *random_id),
       )
       .unwrap();
   }
@@ -136,9 +146,9 @@ impl Pokec
     let random_id = self.ids.choose(rng).unwrap();
     self
       .connection
-      .execute_query(
+      .execute_oc_query(
         "MATCH (s:User {id: $id})-->()-->(n:User) WHERE n.age >= 18 RETURN n.id",
-        map!("$id" => *random_id),
+        value_map!("$id" => *random_id),
       )
       .unwrap();
   }
@@ -149,9 +159,9 @@ impl Pokec
     let random_id = self.ids.choose(rng).unwrap();
     self
       .connection
-      .execute_query(
+      .execute_oc_query(
         "MATCH (n:User {id: $id})-[e1]->(m)-[e2]->(n) RETURN e1, m, e2",
-        map!("$id" => *random_id),
+        value_map!("$id" => *random_id),
       )
       .unwrap();
   }
@@ -159,14 +169,14 @@ impl Pokec
   {
     self
       .connection
-      .execute_query("MATCH (n:User) RETURN n.age, count(*)", Default::default())
+      .execute_oc_query("MATCH (n:User) RETURN n.age, count(*)", Default::default())
       .unwrap();
   }
   pub(crate) fn aggregate_count_filter(&self)
   {
     self
       .connection
-      .execute_query(
+      .execute_oc_query(
         "MATCH (n:User) WHERE n.age >= 18 RETURN n.age, count(*)",
         Default::default(),
       )
@@ -176,7 +186,7 @@ impl Pokec
   {
     self
       .connection
-      .execute_query(
+      .execute_oc_query(
         "MATCH (n) RETURN min(n.age), max(n.age), avg(n.age)",
         Default::default(),
       )

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/aggregators/arithmetic.rs

@@ -41,6 +41,7 @@ where
     match self.value
     {
       Value::Boolean(..)
+      | Value::Key(..)
       | Value::Node(..)
       | Value::Edge(..)
       | Value::Array(..)

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/aggregators/stats.rs

@@ -2,16 +2,12 @@ use std::fmt::Debug;
 
 use super::AggregatorState;
 
-use crate::{
-  error::{InternalError, RunTimeError},
-  value::Value,
-  Result,
-};
+use crate::prelude::*;
 
 #[derive(Debug)]
 struct AvgState
 {
-  value: Value,
+  value: value::Value,
   count: usize,
 }
 
@@ -20,7 +16,7 @@ impl AvgState
   fn new() -> Result<Self>
   {
     Ok(Self {
-      value: Value::Null,
+      value: value::Value::Null,
       count: 0,
     })
   }
@@ -28,7 +24,7 @@ impl AvgState
 
 impl AggregatorState for AvgState
 {
-  fn next(&mut self, value: Value) -> crate::Result<()>
+  fn next(&mut self, value: value::Value) -> crate::Result<()>
   {
     if self.value.is_null()
     {
@@ -38,25 +34,25 @@ impl AggregatorState for AvgState
     {
       match value
       {
-        Value::Null =>
+        value::Value::Null =>
         {}
-        Value::Integer(i) =>
+        value::Value::Integer(i) =>
         {
           self.count += 1;
           match self.value
           {
-            Value::Integer(vi) => self.value = (vi + i).into(),
-            Value::Float(vf) => self.value = (vf + i as f64).into(),
+            value::Value::Integer(vi) => self.value = (vi + i).into(),
+            value::Value::Float(vf) => self.value = (vf + i as f64).into(),
             _ => Err(InternalError::InvalidAggregationState)?,
           }
         }
-        Value::Float(f) =>
+        value::Value::Float(f) =>
         {
           self.count += 1;
           match self.value
           {
-            Value::Integer(vi) => self.value = (vi as f64 + f).into(),
-            Value::Float(vf) => self.value = (vf + f).into(),
+            value::Value::Integer(vi) => self.value = (vi as f64 + f).into(),
+            value::Value::Float(vf) => self.value = (vf + f).into(),
             _ => Err(InternalError::InvalidAggregationState)?,
           }
         }
@@ -69,50 +65,41 @@ impl AggregatorState for AvgState
   {
     match self.value
     {
-      Value::Null => Ok(Value::Null),
-      Value::Integer(vi) => Ok((vi / self.count as i64).into()),
-      Value::Float(vf) => Ok((vf / self.count as f64).into()),
+      value::Value::Null => Ok(value::Value::Null),
+      value::Value::Integer(vi) => Ok((vi / self.count as i64).into()),
+      value::Value::Float(vf) => Ok((vf / self.count as f64).into()),
       _ => Err(InternalError::InvalidAggregationState)?,
     }
   }
 }
 
-super::declare_aggregator!(avg, Avg, AvgState, () -> Value);
+super::declare_aggregator!(avg, Avg, AvgState, () -> value::Value);
 
 #[derive(Debug)]
 struct MinState
 {
-  value: Value,
+  value: value::Value,
 }
 
 impl MinState
 {
   fn new() -> Result<Self>
   {
-    Ok(Self { value: Value::Null })
+    Ok(Self {
+      value: value::Value::Null,
+    })
   }
 }
 
 impl AggregatorState for MinState
 {
-  fn next(&mut self, value: Value) -> crate::Result<()>
+  fn next(&mut self, value: value::Value) -> crate::Result<()>
   {
     if self.value.is_null()
+      || (!value.is_null() && value.orderability(&self.value) == std::cmp::Ordering::Less)
     {
       self.value = value;
     }
-    else if !value.is_null()
-    {
-      match value.orderability(&self.value)
-      {
-        std::cmp::Ordering::Less =>
-        {
-          self.value = value;
-        }
-        _ =>
-        {}
-      }
-    }
     Ok(())
   }
   fn finalise(self: Box<Self>) -> crate::Result<crate::value::Value>
@@ -126,37 +113,28 @@ super::declare_aggregator!(min, Min, MinState, () -> i64);
 #[derive(Debug)]
 struct MaxState
 {
-  value: Value,
+  value: value::Value,
 }
 
 impl MaxState
 {
   fn new() -> Result<Self>
   {
-    Ok(Self { value: Value::Null })
+    Ok(Self {
+      value: value::Value::Null,
+    })
   }
 }
 
 impl AggregatorState for MaxState
 {
-  fn next(&mut self, value: Value) -> crate::Result<()>
+  fn next(&mut self, value: value::Value) -> crate::Result<()>
   {
     if self.value.is_null()
+      || (!value.is_null() && value.orderability(&self.value) == std::cmp::Ordering::Greater)
     {
       self.value = value;
     }
-    else if !value.is_null()
-    {
-      match value.orderability(&self.value)
-      {
-        std::cmp::Ordering::Greater =>
-        {
-          self.value = value;
-        }
-        _ =>
-        {}
-      }
-    }
     Ok(())
   }
   fn finalise(self: Box<Self>) -> crate::Result<crate::value::Value>

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

@@ -28,7 +28,7 @@ macro_rules! declare_aggregator {
     pub(super) struct $type_name {}
     impl $type_name
     {
-      pub(crate) fn new() -> (String, crate::aggregators::Aggregator)
+      pub(crate) fn create() -> (String, crate::aggregators::Aggregator)
       {
         (
           stringify!($function_name).to_string(),
@@ -63,12 +63,12 @@ pub(crate) use declare_aggregator;
 pub(crate) fn init_aggregators() -> std::collections::HashMap<String, Aggregator>
 {
   [
-    count::Count::new(),
-    arithmetic::Sum::new(),
-    containers::Collect::new(),
-    stats::Avg::new(),
-    stats::Min::new(),
-    stats::Max::new(),
+    count::Count::create(),
+    arithmetic::Sum::create(),
+    containers::Collect::create(),
+    stats::Avg::create(),
+    stats::Min::create(),
+    stats::Max::create(),
   ]
   .into()
 }

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

@@ -173,11 +173,13 @@ pub extern "C" fn gqlite_connection_query(
     let conn = unsafe { Box::from_raw(connection) };
     let result = conn
       .connection
-      .execute_query(query, get_value(bindings).into_map());
+      .execute_oc_query(query, get_value(bindings).into_map());
     let _ = Box::into_raw(conn);
     if let Ok(v) = handle_error(context, result)
     {
-      return Box::into_raw(Box::new(GqliteValueT { value: v }));
+      return Box::into_raw(Box::new(GqliteValueT {
+        value: v.into_value(),
+      }));
     }
   }
   std::ptr::null::<GqliteValueT>() as *mut GqliteValueT
@@ -222,7 +224,7 @@ pub extern "C" fn gqlite_value_to_json(
     return r;
   }
   let _ = Box::into_raw(value);
-  return std::ptr::null();
+  std::ptr::null()
 }
 
 #[no_mangle]
@@ -241,7 +243,7 @@ pub extern "C" fn gqlite_value_from_json(
       return Box::into_raw(Box::new(GqliteValueT { value: v }));
     }
   }
-  return std::ptr::null::<GqliteValueT>() as *mut GqliteValueT;
+  std::ptr::null::<GqliteValueT>() as *mut GqliteValueT
 }
 
 #[no_mangle]
@@ -251,9 +253,8 @@ pub extern "C" fn gqlite_value_is_valid(
 ) -> bool
 {
   check_error(context);
-  match unsafe { (*value).value.borrow() }
-  {
-    crate::value::Value::Null => false,
-    _ => true,
-  }
+  !matches!(
+    unsafe { (*value).value.borrow() },
+    crate::value::Value::Null
+  )
 }

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/compiler/expression_analyser.rs

@@ -11,6 +11,7 @@ use crate::{compiler::variables_manager::VariablesManager, parser::ast, prelude:
 pub(crate) enum ExpressionType
 {
   Array,
+  Key,
   Map,
   Node,
   Edge,
@@ -134,7 +135,7 @@ where
   }
 }
 
-impl<'a, VT> ExpressionAnalyser for (&'a ast::Expression, VT)
+impl<VT> ExpressionAnalyser for (&ast::Expression, VT)
 where
   VT: Fn(ExpressionInfo) -> Result<ExpressionInfo>,
 {
@@ -188,8 +189,8 @@ impl ExpressionInfo
     let dependents = dependents.into();
     Self {
       expression_type,
-      constant: dependents.iter().all(|x| x.constant == true),
-      aggregation_result: dependents.into_iter().any(|x| x.aggregation_result == true),
+      constant: dependents.iter().all(|x| x.constant),
+      aggregation_result: dependents.into_iter().any(|x| x.aggregation_result),
     }
   }
 }
@@ -253,7 +254,7 @@ impl<'b> Analyser<'b>
             arguments.iter().map(|x| x.expression_type).collect(),
           )?,
           self.functions_manager.is_deterministic(&call.name)?
-            && arguments.iter().all(|x| x.constant == true),
+            && arguments.iter().all(|x| x.constant),
           self.functions_manager.is_aggregate(&call.name)?,
         ))
       }
@@ -408,6 +409,7 @@ impl<'b> Analyser<'b>
         match val.value
         {
           value::Value::Array(_) => ExpressionType::Array,
+          value::Value::Key(_) => ExpressionType::Key,
           value::Value::Boolean(_) => ExpressionType::Boolean,
           value::Value::Edge(_) => ExpressionType::Edge,
           value::Value::Node(_) => ExpressionType::Node,