gqlite 1.5.0 → 1.7.0

data/ext/gqlitedb/benches/common/pokec.rs

@@ -1,8 +1,8 @@
 use std::{collections::HashSet, fs};
 
 use ccutils::temporary::TemporaryFile;
-use gqlitedb::{value_map, Connection};
-use rand::{seq::IndexedRandom, Rng};
+use gqlitedb::{Connection, value_map};
+use rand::{Rng, seq::IndexedRandom};
 use regex::Regex;
 
 /// Marker trait to keep backend-specific resources alive for the benchmark lifetime.
@@ -244,4 +244,64 @@ impl Pokec
       )
       .unwrap();
   }
+  pub(crate) fn scan_limit_1(&self)
+  {
+    self
+      .connection
+      .execute_oc_query("MATCH (n:User) RETURN n LIMIT 1", Default::default())
+      .unwrap();
+  }
+  pub(crate) fn scan_limit_10(&self)
+  {
+    self
+      .connection
+      .execute_oc_query("MATCH (n:User) RETURN n LIMIT 10", Default::default())
+      .unwrap();
+  }
+  pub(crate) fn scan_limit_100(&self)
+  {
+    self
+      .connection
+      .execute_oc_query("MATCH (n:User) RETURN n LIMIT 100", Default::default())
+      .unwrap();
+  }
+  pub(crate) fn recursive_1_2<R>(&self, rng: &mut R)
+  where
+    R: Rng + ?Sized,
+  {
+    let random_id = self.ids.choose(rng).unwrap();
+    self
+      .connection
+      .execute_oc_query(
+        "MATCH (s:User {id: $id})-[*1..2]->(n:User) RETURN n.id",
+        value_map!("$id" => *random_id),
+      )
+      .unwrap();
+  }
+  pub(crate) fn recursive_1_3<R>(&self, rng: &mut R)
+  where
+    R: Rng + ?Sized,
+  {
+    let random_id = self.ids.choose(rng).unwrap();
+    self
+      .connection
+      .execute_oc_query(
+        "MATCH (s:User {id: $id})-[*1..3]->(n:User) RETURN n.id",
+        value_map!("$id" => *random_id),
+      )
+      .unwrap();
+  }
+  pub(crate) fn recursive_1_2_filter<R>(&self, rng: &mut R)
+  where
+    R: Rng + ?Sized,
+  {
+    let random_id = self.ids.choose(rng).unwrap();
+    self
+      .connection
+      .execute_oc_query(
+        "MATCH (s:User {id: $id})-[*1..2]->(n:User) WHERE n.age >= 18 RETURN n.id",
+        value_map!("$id" => *random_id),
+      )
+      .unwrap();
+  }
 }

data/ext/gqlitedb/benches/pokec_divan.rs

@@ -1,5 +1,5 @@
 use divan::Bencher;
-use rand::{rngs::StdRng, SeedableRng};
+use rand::{SeedableRng, rngs::StdRng};
 
 mod common;
 
@@ -8,6 +8,8 @@ use common::pokec::{Pokec, PokecSize};
 const FRIEND_OF_COUNT: u32 = 100;
 const SINGLE_VERTEX_COUNT: u32 = 100;
 const IMPORT_COUNT: u32 = 30;
+const LIMIT_COUNT: u32 = 200;
+const RECURSIVE_COUNT: u32 = 100;
 
 fn main()
 {
@@ -125,7 +127,6 @@ fn aggregate_count_filter(bencher: Bencher, backend: &str)
     tiny_pokec.aggregate_count_filter();
   });
 }
-
 #[divan::bench(args = ["postgres", "sqlite", "redb"])]
 fn aggregate_min_max_avg(bencher: Bencher, backend: &str)
 {
@@ -135,3 +136,66 @@ fn aggregate_min_max_avg(bencher: Bencher, backend: &str)
     tiny_pokec.aggregate_min_max_avg();
   });
 }
+
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = LIMIT_COUNT)]
+fn scan_limit_1(bencher: Bencher, backend: &str)
+{
+  let pokec = load_pokec(backend);
+
+  bencher.bench_local(move || {
+    pokec.scan_limit_1();
+  });
+}
+
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = LIMIT_COUNT)]
+fn scan_limit_10(bencher: Bencher, backend: &str)
+{
+  let pokec = load_pokec(backend);
+
+  bencher.bench_local(move || {
+    pokec.scan_limit_10();
+  });
+}
+
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = LIMIT_COUNT)]
+fn scan_limit_100(bencher: Bencher, backend: &str)
+{
+  let pokec = load_pokec(backend);
+
+  bencher.bench_local(move || {
+    pokec.scan_limit_100();
+  });
+}
+
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = RECURSIVE_COUNT)]
+fn recursive_1_2(bencher: Bencher, backend: &str)
+{
+  let pokec = load_pokec(backend).read_ids();
+  let mut rng = StdRng::seed_from_u64(991173);
+
+  bencher.bench_local(move || {
+    pokec.recursive_1_2(&mut rng);
+  });
+}
+
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = RECURSIVE_COUNT)]
+fn recursive_1_3(bencher: Bencher, backend: &str)
+{
+  let pokec = load_pokec(backend).read_ids();
+  let mut rng = StdRng::seed_from_u64(991173);
+
+  bencher.bench_local(move || {
+    pokec.recursive_1_3(&mut rng);
+  });
+}
+
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = RECURSIVE_COUNT)]
+fn recursive_1_2_filter(bencher: Bencher, backend: &str)
+{
+  let pokec = load_pokec(backend).read_ids();
+  let mut rng = StdRng::seed_from_u64(991173);
+
+  bencher.bench_local(move || {
+    pokec.recursive_1_2_filter(&mut rng);
+  });
+}

data/ext/gqlitedb/benches/pokec_iai.rs

@@ -1,7 +1,7 @@
 use std::hint::black_box;
 
 use iai_callgrind::{library_benchmark, library_benchmark_group, main};
-use rand::{rngs::StdRng, SeedableRng};
+use rand::{SeedableRng, rngs::StdRng};
 
 mod common;
 
@@ -123,11 +123,68 @@ fn aggregate_min_max_avg(micro_pokec: Pokec)
   micro_pokec.aggregate_min_max_avg();
 }
 
+#[library_benchmark(setup = load_pokec)]
+#[bench::postgres("postgres")]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn scan_limit_1(micro_pokec: Pokec)
+{
+  micro_pokec.scan_limit_1();
+}
+
+#[library_benchmark(setup = load_pokec)]
+#[bench::postgres("postgres")]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn scan_limit_10(micro_pokec: Pokec)
+{
+  micro_pokec.scan_limit_10();
+}
+
+#[library_benchmark(setup = load_pokec)]
+#[bench::postgres("postgres")]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn scan_limit_100(micro_pokec: Pokec)
+{
+  micro_pokec.scan_limit_100();
+}
+
+#[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn recursive_1_2(micro_pokec: Pokec)
+{
+  let mut rng = StdRng::seed_from_u64(991173);
+  micro_pokec.recursive_1_2(&mut rng);
+}
+
+#[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn recursive_1_3(micro_pokec: Pokec)
+{
+  let mut rng = StdRng::seed_from_u64(991173);
+  micro_pokec.recursive_1_3(&mut rng);
+}
+
+#[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn recursive_1_2_filter(micro_pokec: Pokec)
+{
+  let mut rng = StdRng::seed_from_u64(991173);
+  micro_pokec.recursive_1_2_filter(&mut rng);
+}
+
 library_benchmark_group!(
     name = bench_micro_pokec_group;
-    benchmarks = import_micro_pokec, single_vertex, single_vertex_where, friend_of, friend_of_filter, friend_of_friend_of, friend_of_friend_of_filter, reciprocal_friends, aggregate_count, aggregate_count_filter, aggregate_min_max_avg
+    benchmarks = recursive_1_2, import_micro_pokec, single_vertex, single_vertex_where, friend_of, friend_of_filter, friend_of_friend_of, friend_of_friend_of_filter, reciprocal_friends, aggregate_count, aggregate_count_filter, aggregate_min_max_avg, scan_limit_1, scan_limit_10, scan_limit_100, recursive_1_3, recursive_1_2_filter
 );
 
 main!(
-  setup = common::get_bench_data(); 
+  setup = common::get_bench_data();
   library_benchmark_groups = bench_micro_pokec_group);

data/ext/gqlitedb/release.toml

@@ -1,7 +1,7 @@
 pre-release-replacements = [
   { file = "../../CHANGELOG.md", search = "Unreleased", replace = "{{version}}" },
-  { file = "../../CHANGELOG.md", search = "\\.\\.\\.dev/1", replace = "...{{tag_name}}", exactly = 1 },
+  { file = "../../CHANGELOG.md", search = "\\.\\.\\.dev/1", replace = "...gqlitedb-v{{version}}", exactly = 1 },
   { file = "../../CHANGELOG.md", search = "ReleaseDate", replace = "{{date}}" },
   { file = "../../CHANGELOG.md", search = "<!-- next-header -->", replace = "<!-- next-header -->\n\n## [Unreleased] - ReleaseDate", exactly = 1 },
-  { file = "../../CHANGELOG.md", search = "<!-- next-url -->", replace = "<!-- next-url -->\n[Unreleased]: https://gitlab.com/gqlite/gqlite/compare/{{tag_name}}...dev/1", exactly = 1 },
+  { file = "../../CHANGELOG.md", search = "<!-- next-url -->", replace = "<!-- next-url -->\n[Unreleased]: https://gitlab.com/auksys/gqlite/compare/gqlitedb-v{{version}}...dev/1", exactly = 1 },
 ]

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

@@ -2,7 +2,7 @@ use std::fmt::Debug;
 
 use super::AggregatorState;
 
-use crate::{error::RunTimeError, value::Value, Result};
+use crate::{Result, error::RunTimeError, value::Value};
 
 trait Op
 {
@@ -45,9 +45,11 @@ where
       | Value::Node(..)
       | Value::Edge(..)
       | Value::Array(..)
+      | Value::Tensor(..)
       | Value::String(..)
       | Value::TimeStamp(..)
       | Value::Map(..)
+      | Value::SinglePath(..)
       | Value::Path(..) => Err(RunTimeError::InvalidBinaryOperands)?,
       Value::Null =>
       {

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

@@ -1,6 +1,6 @@
 use super::AggregatorState;
 
-use crate::{value::Value, Result};
+use crate::{Result, value::Value};
 
 #[derive(Debug)]
 struct CollectState

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

@@ -26,17 +26,17 @@ impl AggregatorState for AvgState
 {
   fn next(&mut self, value: value::Value) -> crate::Result<()>
   {
-    if self.value.is_null()
-    {
-      self.value = value;
-    }
-    else
+    match value
     {
-      match value
+      value::Value::Null => Ok(()),
+      value::Value::Integer(i) =>
       {
-        value::Value::Null =>
-        {}
-        value::Value::Integer(i) =>
+        if self.value.is_null()
+        {
+          self.value = value::Value::Integer(i);
+          self.count = 1;
+        }
+        else
         {
           self.count += 1;
           match self.value
@@ -46,7 +46,16 @@ impl AggregatorState for AvgState
             _ => Err(InternalError::InvalidAggregationState)?,
           }
         }
-        value::Value::Float(f) =>
+        Ok(())
+      }
+      value::Value::Float(f) =>
+      {
+        if self.value.is_null()
+        {
+          self.value = value::Value::Float(f);
+          self.count = 1;
+        }
+        else
         {
           self.count += 1;
           match self.value
@@ -56,10 +65,10 @@ impl AggregatorState for AvgState
             _ => Err(InternalError::InvalidAggregationState)?,
           }
         }
-        _ => Err(RunTimeError::InvalidArgumentType)?,
+        Ok(())
       }
+      _ => Err(RunTimeError::InvalidArgumentType)?,
     }
-    Ok(())
   }
   fn finalise(self: Box<Self>) -> crate::Result<crate::value::Value>
   {

data/ext/gqlitedb/src/capi.rs

@@ -41,7 +41,7 @@ fn check_error(context: *mut GqliteApiContextT)
   {
     let context = unsafe { Box::from_raw(context) };
     let stri = context.string.to_str().unwrap();
-    println!("Error message '{stri:?}' was not cleared from context!");
+    log::error!("Error message '{stri:?}' was not cleared from context!");
     let _ = Box::into_raw(context);
   }
 }
@@ -65,7 +65,7 @@ pub struct GqliteValueT
   value: crate::value::Value,
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn gqlite_api_context_create() -> *mut GqliteApiContextT
 {
   Box::into_raw(Box::new(GqliteApiContextT {
@@ -74,7 +74,7 @@ pub extern "C" fn gqlite_api_context_create() -> *mut GqliteApiContextT
   }))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn gqlite_api_context_destroy(context: *mut GqliteApiContextT)
 {
   unsafe {
@@ -82,7 +82,7 @@ pub extern "C" fn gqlite_api_context_destroy(context: *mut GqliteApiContextT)
   }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn gqlite_api_context_get_message(
   context: *mut GqliteApiContextT,
 ) -> *const std::ffi::c_char
@@ -90,13 +90,13 @@ pub extern "C" fn gqlite_api_context_get_message(
   unsafe { (*context).string.as_ptr() }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn gqlite_api_context_has_error(context: *mut GqliteApiContextT) -> bool
 {
   unsafe { (*context).has_error }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn gqlite_api_context_clear_error(context: *mut GqliteApiContextT)
 {
   let mut context = unsafe { Box::from_raw(context) };
@@ -104,7 +104,7 @@ pub extern "C" fn gqlite_api_context_clear_error(context: *mut GqliteApiContextT
   let _ = Box::into_raw(context);
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn gqlite_connection_create_from_file(
   context: *mut GqliteApiContextT,
   filename: *const std::ffi::c_char,
@@ -116,22 +116,20 @@ pub extern "C" fn gqlite_connection_create_from_file(
   let path = unsafe { std::ffi::CStr::from_ptr(filename) };
 
   if let Ok(path) = handle_error(context, path.to_str())
-  {
-    if let Ok(c) = handle_error(
+    && let Ok(c) = handle_error(
       context,
       crate::Connection::builder()
         .options(options.into_map())
         .path(path)
         .create(),
     )
-    {
-      return Box::into_raw(Box::new(GqliteConnectionT { connection: c }));
-    }
+  {
+    return Box::into_raw(Box::new(GqliteConnectionT { connection: c }));
   }
   std::ptr::null::<GqliteConnectionT>() as *mut GqliteConnectionT
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn gqlite_connection_create(
   context: *mut GqliteApiContextT,
   options: *mut GqliteValueT,
@@ -147,7 +145,7 @@ pub extern "C" fn gqlite_connection_create(
   std::ptr::null::<GqliteConnectionT>() as *mut GqliteConnectionT
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn gqlite_connection_destroy(
   _context: *mut GqliteApiContextT,
   connection: *mut GqliteConnectionT,
@@ -158,7 +156,7 @@ pub extern "C" fn gqlite_connection_destroy(
   }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn gqlite_connection_query(
   context: *mut GqliteApiContextT,
   connection: *mut GqliteConnectionT,
@@ -185,7 +183,7 @@ pub extern "C" fn gqlite_connection_query(
   std::ptr::null::<GqliteValueT>() as *mut GqliteValueT
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn gqlite_value_create(context: *mut GqliteApiContextT) -> *mut GqliteValueT
 {
   check_error(context);
@@ -194,7 +192,7 @@ pub extern "C" fn gqlite_value_create(context: *mut GqliteApiContextT) -> *mut G
   }))
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn gqlite_value_destroy(context: *mut GqliteApiContextT, value: *mut GqliteValueT)
 {
   check_error(context);
@@ -203,7 +201,7 @@ pub extern "C" fn gqlite_value_destroy(context: *mut GqliteApiContextT, value: *
   }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn gqlite_value_to_json(
   context: *mut GqliteApiContextT,
   value: *mut GqliteValueT,
@@ -227,7 +225,7 @@ pub extern "C" fn gqlite_value_to_json(
   std::ptr::null()
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn gqlite_value_from_json(
   context: *mut GqliteApiContextT,
   json: *const std::ffi::c_char,
@@ -237,16 +235,14 @@ pub extern "C" fn gqlite_value_from_json(
 
   let json = unsafe { std::ffi::CStr::from_ptr(json) };
   if let Ok(json) = handle_error(context, json.to_str())
+    && let Ok(v) = handle_error(context, serde_json::from_str::<crate::value::Value>(json))
   {
-    if let Ok(v) = handle_error(context, serde_json::from_str::<crate::value::Value>(json))
-    {
-      return Box::into_raw(Box::new(GqliteValueT { value: v }));
-    }
+    return Box::into_raw(Box::new(GqliteValueT { value: v }));
   }
   std::ptr::null::<GqliteValueT>() as *mut GqliteValueT
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "C" fn gqlite_value_is_valid(
   context: *mut GqliteApiContextT,
   value: *mut GqliteValueT,

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

@@ -1,4 +1,6 @@
-use crate::{compiler::variables_manager::VariablesManager, parser::ast, prelude::*};
+use gqlparser::oc::ast;
+
+use crate::{compiler::variables_manager::VariablesManager, prelude::*};
 
 // __     __         _       _     _     _____
 // \ \   / /_ _ _ __(_) __ _| |__ | | __|_   _|   _ _ __   ___
@@ -23,6 +25,8 @@ pub(crate) enum ExpressionType
   String,
   TimeStamp,
   Variant,
+  #[expect(dead_code)]
+  Tensor,
 }
 
 //             _ _     _       _
@@ -34,7 +38,7 @@ pub(crate) enum ExpressionType
 
 mod validators
 {
-  use crate::{error, Result};
+  use crate::{Result, error};
 
   use super::{ExpressionInfo, ExpressionType};
 
@@ -136,15 +140,15 @@ where
   }
 }
 
-impl<VT> ExpressionAnalyser for (&ast::Expression, VT)
-where
-  VT: Fn(ExpressionInfo) -> Result<ExpressionInfo>,
-{
-  fn analyse<'b>(self, analyser: &Analyser<'b>) -> Result<Vec<ExpressionInfo>>
-  {
-    Ok(vec![self.1(analyser.analyse(self.0)?)?])
-  }
-}
+// impl<VT> ExpressionAnalyser for (&ast::Expression, VT)
+// where
+//   VT: Fn(ExpressionInfo) -> Result<ExpressionInfo>,
+// {
+//   fn analyse<'b>(self, analyser: &Analyser<'b>) -> Result<Vec<ExpressionInfo>>
+//   {
+//     Ok(vec![self.1(analyser.analyse(self.0)?)?])
+//   }
+// }
 
 impl<'a, VT0, VT1> ExpressionAnalyser for ((&'a ast::Expression, &'a ast::Expression), (VT0, VT1))
 where
@@ -154,8 +158,8 @@ where
   fn analyse<'b>(self, analyser: &Analyser<'b>) -> Result<Vec<ExpressionInfo>>
   {
     Ok(vec![
-      self.1 .0(analyser.analyse(self.0 .0)?)?,
-      self.1 .1(analyser.analyse(self.0 .1)?)?,
+      self.1.0(analyser.analyse(self.0.0)?)?,
+      self.1.1(analyser.analyse(self.0.1)?)?,
     ])
   }
 }
@@ -171,17 +175,21 @@ where
 pub(crate) struct ExpressionInfo
 {
   pub(crate) expression_type: ExpressionType,
-  pub(crate) constant: bool,
+  /// runtime constant indicates a constant that can be evaluated during compilation, but
+  /// that might not always be deterministic. For instance, `toInteger(rand()*9)` is such
+  /// a contant.
+  pub(crate) runtime_constant: bool,
   pub(crate) aggregation_result: bool,
 }
 
 impl ExpressionInfo
 {
-  fn new(expression_type: ExpressionType, constant: bool, aggregation_result: bool) -> Self
+  fn new(expression_type: ExpressionType, runtime_constant: bool, aggregation_result: bool)
+  -> Self
   {
     Self {
       expression_type,
-      constant,
+      runtime_constant,
       aggregation_result,
     }
   }
@@ -190,7 +198,7 @@ impl ExpressionInfo
     let dependents = dependents.into();
     Self {
       expression_type,
-      constant: dependents.iter().all(|x| x.constant),
+      runtime_constant: dependents.iter().all(|x| x.runtime_constant),
       aggregation_result: dependents.into_iter().any(|x| x.aggregation_result),
     }
   }
@@ -254,8 +262,7 @@ impl<'b> Analyser<'b>
             &call.name,
             arguments.iter().map(|x| x.expression_type).collect(),
           )?,
-          self.functions_manager.is_deterministic(&call.name)?
-            && arguments.iter().all(|x| x.constant),
+          arguments.iter().all(|x| x.runtime_constant),
           self.functions_manager.is_aggregate(&call.name)?,
         ))
       }
@@ -410,6 +417,7 @@ impl<'b> Analyser<'b>
         match val.value
         {
           value::Value::Array(_) => ExpressionType::Array,
+          value::Value::Tensor(_) => ExpressionType::Array,
           value::Value::Key(_) => ExpressionType::Key,
           value::Value::Boolean(_) => ExpressionType::Boolean,
           value::Value::Edge(_) => ExpressionType::Edge,
@@ -418,7 +426,7 @@ impl<'b> Analyser<'b>
           value::Value::Integer(_) => ExpressionType::Integer,
           value::Value::Null => ExpressionType::Null,
           value::Value::Map(_) => ExpressionType::Map,
-          value::Value::Path(_) => ExpressionType::Path,
+          value::Value::SinglePath(_) | value::Value::Path(_) => ExpressionType::Path,
           value::Value::String(_) => ExpressionType::String,
           value::Value::TimeStamp(_) => ExpressionType::TimeStamp,
         },