gqlite 1.2.3 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4f3b9b41902b916ad1893fce53201a6e98b58f9cc20fa66a1f13849f3e84536
-  data.tar.gz: 7dfdb9ac4f71b24332916940e145fbfd513c3be5bcb627575d749825afab88fe
+  metadata.gz: c8b19f14f03ff7f92bf78f132e0c26f800e2d9ce3be108557bb9d23c11e0e8d1
+  data.tar.gz: aad435a97e100195806af926765c90f6c57d1232c51afe771d2b89f00ffa2ea2
 SHA512:
-  metadata.gz: 6d0258dd0e102cc62c193f0ad44e6fe028576be9b879686d8a5feb03bec6c2baefffc4bc4c2db8de3c43fa82eb48622386010c5b287fbb5efdeb92905578e9b9
-  data.tar.gz: f18708c7479c61a90c05b1acb17aa9dc951a608e7225342658c678adb8106a0215b28496a7accb47c58fd78448e5db5b03e735b81b67b83d42653094ffd4b19c
+  metadata.gz: fe9d202a5b338e34141df0240867a68b4f794067dc506d173264a66decd973029dc04f64da9f0a1f6192da8cab652e8c71e8c63a1432c4110259d971d64d3697
+  data.tar.gz: 6f90979086a3be82858d38b62bc23a84ab8a05266ca048541d59c87d5f43757219e88c8a2d7c158762e19533e17720f2d5b583d24d8614a6bbef9196374b6004

data/ext/Cargo.toml

@@ -0,0 +1,20 @@
+[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" }
+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 = { version = "0.4", 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 = { version = "0.4", 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/gqlitedb/gqlite_bench_data/README.MD

@@ -0,0 +1,6 @@
+![GQLite logo](logo.png) GQLite Benchnark Data
+==============================================
+
+This repository includes data used to benchmark GQLite.
+
+* `pokec_tiny_nodes.cypher` is a subset of the [pokec mini](https://github.com/memgraph/memgraph/tree/master/tests/mgbench#pokec) dataset ([original](https://snap.stanford.edu/data/soc-Pokec.html)). 

data/ext/gqlitedb/gqlite_bench_data/scripts/generate_smaller_pokec.rb

@@ -0,0 +1,85 @@
+# Script that reduces the pokec dataset, to reduce it to a subset of users. 
+# It also reduce the initial set of queries into a single one.
+#
+# Use as:
+# ```bash
+# ruby reduce_pokec.rb size input.cypher > output.cypher
+# ```
+
+require 'set'
+
+size = ARGV[0] or abort("Usage: ruby #{$0} micro/tiny input.cypher")
+input_file = ARGV[1] or abort("Usage: ruby #{$0} micro/tiny input.cypher")
+
+if size == "tiny"
+  initial = 5
+  increments = 2
+elsif size == "micro"
+  initial = 1
+  increments = 1
+else
+  abort("Unknown size '#{size}', should be 'tiny' or 'micro'")
+end
+
+user_lines = {}
+all_edges = []
+edges_by_user = Hash.new { |h, k| h[k] = [] }
+selected_edges = []
+seen_edges = Set.new
+selected_users = Set.new
+
+def edge_key(id1, id2)
+  [id1, id2].sort.join('-')
+end
+
+File.foreach(input_file) do |line|
+  if line =~ /CREATE\s+\(:User\s*(\{.*id:\s*(\d+)[^}]*\})\)/i
+    user_lines[$2.to_i] = $1
+
+  elsif line =~ /MATCH\s+\(n:User\s*\{id:\s*(\d+)\}\),\s*\(m:User\s*\{id:\s*(\d+)\}\).*CREATE.*Friend/i
+    id1, id2 = $1.to_i, $2.to_i
+    edge = { line: line, ids: [id1, id2] }
+    all_edges << edge
+    edges_by_user[id1] << edge
+    edges_by_user[id2] << edge
+  end
+end
+
+# Step 1: Select initial edges
+initial_edges = all_edges.take(initial)
+initial_edges.each do |edge|
+  k = edge_key(*edge[:ids])
+  next if seen_edges.include?(k)
+
+  seen_edges << k
+  selected_edges << edge
+  selected_users.merge(edge[:ids])
+end
+
+# Step 2: Find all other edges connected to selected users
+for i in 0...increments
+  for uid in selected_users.clone()
+    edges_by_user[uid].each do |edge|
+      k = edge_key(*edge[:ids])
+      next if seen_edges.include?(k)
+
+      seen_edges << k
+      selected_edges << edge
+
+      # Add any new user ID to the queue
+      selected_users.merge(edge[:ids])
+    end
+  end
+end
+
+puts "CREATE"
+# Output user CREATEs
+selected_users.each do |id|
+  puts "  (user_#{id}:User #{user_lines[id]})," if user_lines.key?(id)
+end
+
+# Output edges
+selected_edges.each do |edge|
+  ids = edge[:ids]
+  puts "  (user_#{ids[0]})-[:Friend]->(user_#{ids[1]}),"
+end

data/ext/gqlitedb/gqlite_bench_data/scripts/to_efficient_pokec.rb

@@ -0,0 +1,34 @@
+# Script that transform the pokec dataset into a more efficient query.
+#
+# Use as:
+# ```bash
+# ruby to_efficient_pokec.rb input.cypher > output.cypher
+# ```
+
+require 'set'
+
+input_file = ARGV[0] or abort("Usage: ruby #{$0} input.cypher")
+
+user_lines = []
+edge_lines = []
+
+File.foreach(input_file) do |line|
+  if line =~ /CREATE\s+\(:User\s*(\{.*id:\s*(\d+)[^}]*\})\)/i
+    user_lines.append({ id: $2.to_i, data: $1})
+
+  elsif line =~ /MATCH\s+\(n:User\s*\{id:\s*(\d+)\}\),\s*\(m:User\s*\{id:\s*(\d+)\}\).*CREATE.*Friend/i
+    id1, id2 = $1.to_i, $2.to_i
+    edge_lines.append({ id1: id1, id2: id2 })
+  end
+end
+
+puts "CREATE"
+# Output user CREATEs
+user_lines.each do |user|
+  puts "  (user_#{user[:id]}:User #{user[:data]}),"
+end
+
+# Output edges
+edge_lines.each do |edge|
+  puts "  (user_#{edge[:id1]})-[:Friend]->(user_#{edge[:id2]}),"
+end

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,