gqlite 1.2.0 → 1.2.3

data/ext/gqliterb/vendor/gqlitedb/Cargo.toml

@@ -0,0 +1,138 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+name = "gqlitedb"
+version = "0.5.3"
+build = false
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+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."
+homepage = "https://gqlite.org"
+readme = "README.md"
+license = "MIT"
+repository = "https://gitlab.com/gqlite/gqlite"
+
+[features]
+_backtrace = []
+_pg13 = ["pgrx/pg13"]
+_pg14 = ["pgrx/pg14"]
+_pg15 = ["pgrx/pg15"]
+_pg16 = ["pgrx/pg16"]
+_pg17 = ["pgrx/pg17"]
+_pgql = ["dep:pgrx"]
+_value_private = []
+capi = []
+default = [
+    "redb",
+    "capi",
+    "sqlite",
+]
+redb = ["dep:redb"]
+sqlite = [
+    "dep:rusqlite",
+    "dep:askama",
+]
+
+[lib]
+name = "gqlitedb"
+crate-type = [
+    "cdylib",
+    "lib",
+]
+path = "src/lib.rs"
+
+[[bench]]
+name = "pokec_divan"
+path = "benches/pokec_divan.rs"
+harness = false
+
+[[bench]]
+name = "pokec_iai"
+path = "benches/pokec_iai.rs"
+harness = false
+
+[dependencies.askama]
+version = "0.14"
+optional = true
+
+[dependencies.ccutils]
+version = "0.3"
+features = [
+    "sync",
+    "pool",
+]
+
+[dependencies.ciborium]
+version = "0.2"
+
+[dependencies.itertools]
+version = "0.14"
+
+[dependencies.pest]
+version = "2"
+
+[dependencies.pest_derive]
+version = "2"
+
+[dependencies.pgrx]
+version = "0.15"
+optional = true
+
+[dependencies.rand]
+version = "0.9"
+
+[dependencies.redb]
+version = "2"
+optional = true
+
+[dependencies.rusqlite]
+version = "0.37"
+features = [
+    "functions",
+    "uuid",
+]
+optional = true
+package = "rusqlite"
+
+[dependencies.serde]
+version = "1"
+
+[dependencies.serde_json]
+version = "1"
+
+[dependencies.thiserror]
+version = "2"
+
+[dependencies.uuid]
+version = "1"
+features = ["v4"]
+
+[dev-dependencies.ccutils]
+version = "0.3"
+features = ["temporary"]
+
+[dev-dependencies.divan]
+version = "0.1"
+
+[dev-dependencies.iai-callgrind]
+version = "0.16"
+
+[dev-dependencies.regex]
+version = "1"
+
+[target.'cfg(target_arch = "wasm32")'.dependencies.uuid]
+version = "1"
+features = ["js"]

data/ext/gqliterb/vendor/gqlitedb/askama.toml

@@ -0,0 +1,3 @@
+[[escaper]]
+path = ""
+extensions = ["sql"]

data/ext/gqliterb/vendor/gqlitedb/benches/common/mod.rs

@@ -0,0 +1,25 @@
+pub(crate) mod pokec;
+
+pub(crate) fn get_bench_data()
+{
+  if std::fs::exists("gqlite_bench_data").unwrap()
+  {
+    std::process::Command::new("git")
+      .arg("pull")
+      .spawn()
+      .unwrap()
+      .wait()
+      .unwrap();
+  }
+  else
+  {
+    std::process::Command::new("git")
+      .arg("clone")
+      .arg("https://gitlab.com/auksys/data/gqlite_bench.git")
+      .arg("gqlite_bench_data")
+      .spawn()
+      .unwrap()
+      .wait()
+      .unwrap();
+  }
+}

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

@@ -0,0 +1,185 @@
+use std::{collections::HashSet, fs};
+
+use ccutils::temporary::TemporaryFile;
+use gqlitedb::{map, Connection};
+use rand::{seq::IndexedRandom, Rng};
+use regex::Regex;
+
+pub(crate) struct Pokec
+{
+  #[allow(dead_code)]
+  temporary_file: TemporaryFile,
+  connection: Connection,
+  ids: Vec<i64>,
+}
+
+#[allow(dead_code)]
+pub(crate) enum PokecSize
+{
+  Micro,
+  Tiny,
+}
+
+impl Pokec
+{
+  pub(crate) fn load(backend: &str, size: PokecSize) -> Pokec
+  {
+    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 filename = match size
+    {
+      PokecSize::Micro => "gqlite_bench_data/pokec_micro_import.cypher",
+      PokecSize::Tiny => "gqlite_bench_data/pokec_tiny_import.cypher",
+    };
+
+    let import_query = fs::read_to_string(filename).unwrap();
+
+    connection
+      .execute_query(import_query, Default::default())
+      .unwrap();
+    Self {
+      temporary_file,
+      connection,
+      ids: Default::default(),
+    }
+  }
+  pub(crate) fn read_ids(mut self) -> Self
+  {
+    let re = Regex::new(r"id:\s*(\d+)").unwrap();
+    let mut ids = HashSet::new();
+    let content = fs::read_to_string("gqlite_bench_data/pokec_tiny_import.cypher")
+      .expect("Failed to read the file");
+    for cap in re.captures_iter(&content)
+    {
+      if let Some(id_match) = cap.get(1)
+      {
+        let id = id_match.as_str().parse::<i64>().unwrap();
+        ids.insert(id);
+      }
+    }
+    self.ids = ids.into_iter().collect();
+    self
+  }
+  pub(crate) fn single_vertex<R>(&self, rng: &mut R)
+  where
+    R: Rng + ?Sized,
+  {
+    let random_id = self.ids.choose(rng).unwrap();
+    self
+      .connection
+      .execute_query(
+        "MATCH (n:User {id: $id}) RETURN n",
+        map!("$id" => *random_id),
+      )
+      .unwrap();
+  }
+  pub(crate) fn single_vertex_where<R>(&self, rng: &mut R)
+  where
+    R: Rng + ?Sized,
+  {
+    let random_id = self.ids.choose(rng).unwrap();
+    self
+      .connection
+      .execute_query(
+        "MATCH (n:User) WHERE n.id = $id RETURN n",
+        map!("$id" => *random_id),
+      )
+      .unwrap();
+  }
+  pub(crate) fn friend_of<R>(&self, rng: &mut R)
+  where
+    R: Rng + ?Sized,
+  {
+    let random_id = self.ids.choose(rng).unwrap();
+    self
+      .connection
+      .execute_query(
+        "MATCH (s:User {id: $id})-->(n:User) RETURN n.id",
+        map!("$id" => *random_id),
+      )
+      .unwrap();
+  }
+  pub(crate) fn friend_of_filter<R>(&self, rng: &mut R)
+  where
+    R: Rng + ?Sized,
+  {
+    let random_id = self.ids.choose(rng).unwrap();
+    self
+      .connection
+      .execute_query(
+        "MATCH (s:User {id: $id})-->(n:User) WHERE n.age >= 18 RETURN n.id",
+        map!("$id" => *random_id),
+      )
+      .unwrap();
+  }
+  pub(crate) fn friend_of_friend_of<R>(&self, rng: &mut R)
+  where
+    R: Rng + ?Sized,
+  {
+    let random_id = self.ids.choose(rng).unwrap();
+    self
+      .connection
+      .execute_query(
+        "MATCH (s:User {id: $id})-->()-->(n:User) RETURN n.id",
+        map!("$id" => *random_id),
+      )
+      .unwrap();
+  }
+  pub(crate) fn friend_of_friend_of_filter<R>(&self, rng: &mut R)
+  where
+    R: Rng + ?Sized,
+  {
+    let random_id = self.ids.choose(rng).unwrap();
+    self
+      .connection
+      .execute_query(
+        "MATCH (s:User {id: $id})-->()-->(n:User) WHERE n.age >= 18 RETURN n.id",
+        map!("$id" => *random_id),
+      )
+      .unwrap();
+  }
+  pub(crate) fn reciprocal_friends<R>(&self, rng: &mut R)
+  where
+    R: Rng + ?Sized,
+  {
+    let random_id = self.ids.choose(rng).unwrap();
+    self
+      .connection
+      .execute_query(
+        "MATCH (n:User {id: $id})-[e1]->(m)-[e2]->(n) RETURN e1, m, e2",
+        map!("$id" => *random_id),
+      )
+      .unwrap();
+  }
+  pub(crate) fn aggregate_count(&self)
+  {
+    self
+      .connection
+      .execute_query("MATCH (n:User) RETURN n.age, count(*)", Default::default())
+      .unwrap();
+  }
+  pub(crate) fn aggregate_count_filter(&self)
+  {
+    self
+      .connection
+      .execute_query(
+        "MATCH (n:User) WHERE n.age >= 18 RETURN n.age, count(*)",
+        Default::default(),
+      )
+      .unwrap();
+  }
+  pub(crate) fn aggregate_min_max_avg(&self)
+  {
+    self
+      .connection
+      .execute_query(
+        "MATCH (n) RETURN min(n.age), max(n.age), avg(n.age)",
+        Default::default(),
+      )
+      .unwrap();
+  }
+}

data/ext/gqliterb/vendor/gqlitedb/benches/pokec_divan.rs

@@ -0,0 +1,137 @@
+use divan::Bencher;
+use rand::{rngs::StdRng, SeedableRng};
+
+mod common;
+
+use common::pokec::{Pokec, PokecSize};
+
+const FRIEND_OF_COUNT: u32 = 100;
+const SINGLE_VERTEX_COUNT: u32 = 100;
+const IMPORT_COUNT: u32 = 30;
+
+fn main()
+{
+  common::get_bench_data();
+
+  // Run registered benchmarks.
+  divan::main();
+}
+
+fn load_pokec(backend: &str) -> Pokec
+{
+  Pokec::load(backend, PokecSize::Tiny)
+}
+
+// Import the tiny `pokec` dataset.
+#[divan::bench(args = ["sqlite", "redb"], sample_count = IMPORT_COUNT)]
+fn import_tiny_pokec(backend: &str)
+{
+  let _ = load_pokec(backend);
+}
+
+#[divan::bench(args = ["sqlite", "redb"], sample_count = SINGLE_VERTEX_COUNT)]
+fn single_vertex(bencher: Bencher, backend: &str)
+{
+  let tiny_pokec = load_pokec(backend).read_ids();
+  let mut rng = StdRng::seed_from_u64(991173);
+
+  bencher.bench_local(move || {
+    tiny_pokec.single_vertex(&mut rng);
+  });
+}
+
+#[divan::bench(args = ["sqlite", "redb"], sample_count = SINGLE_VERTEX_COUNT)]
+fn single_vertex_where(bencher: Bencher, backend: &str)
+{
+  let tiny_pokec = load_pokec(backend).read_ids();
+  let mut rng = StdRng::seed_from_u64(991173);
+
+  bencher.bench_local(move || {
+    tiny_pokec.single_vertex_where(&mut rng);
+  });
+}
+
+#[divan::bench(args = ["sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
+fn friend_of(bencher: Bencher, backend: &str)
+{
+  let tiny_pokec = load_pokec(backend).read_ids();
+  let mut rng = StdRng::seed_from_u64(991173);
+
+  bencher.bench_local(move || {
+    tiny_pokec.friend_of(&mut rng);
+  });
+}
+
+#[divan::bench(args = ["sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
+fn friend_of_filter(bencher: Bencher, backend: &str)
+{
+  let tiny_pokec = load_pokec(backend).read_ids();
+  let mut rng = StdRng::seed_from_u64(991173);
+
+  bencher.bench_local(move || {
+    tiny_pokec.friend_of_filter(&mut rng);
+  });
+}
+
+#[divan::bench(args = ["sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
+fn friend_of_friend_of(bencher: Bencher, backend: &str)
+{
+  let tiny_pokec = load_pokec(backend).read_ids();
+  let mut rng = StdRng::seed_from_u64(991173);
+
+  bencher.bench_local(move || {
+    tiny_pokec.friend_of_friend_of(&mut rng);
+  });
+}
+
+#[divan::bench(args = ["sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
+fn friend_of_friend_of_filter(bencher: Bencher, backend: &str)
+{
+  let tiny_pokec = load_pokec(backend).read_ids();
+  let mut rng = StdRng::seed_from_u64(991173);
+
+  bencher.bench_local(move || {
+    tiny_pokec.friend_of_friend_of_filter(&mut rng);
+  });
+}
+
+#[divan::bench(args = ["sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
+fn reciprocal_friends(bencher: Bencher, backend: &str)
+{
+  let tiny_pokec = load_pokec(backend).read_ids();
+  let mut rng = StdRng::seed_from_u64(991173);
+
+  bencher.bench_local(move || {
+    tiny_pokec.reciprocal_friends(&mut rng);
+  });
+}
+
+#[divan::bench(args = ["sqlite", "redb"])]
+fn aggregate_count(bencher: Bencher, backend: &str)
+{
+  let tiny_pokec = load_pokec(backend);
+
+  bencher.bench_local(move || {
+    tiny_pokec.aggregate_count();
+  });
+}
+
+#[divan::bench(args = ["sqlite", "redb"])]
+fn aggregate_count_filter(bencher: Bencher, backend: &str)
+{
+  let tiny_pokec = load_pokec(backend);
+
+  bencher.bench_local(move || {
+    tiny_pokec.aggregate_count_filter();
+  });
+}
+
+#[divan::bench(args = ["sqlite", "redb"])]
+fn aggregate_min_max_avg(bencher: Bencher, backend: &str)
+{
+  let tiny_pokec = load_pokec(backend);
+
+  bencher.bench_local(move || {
+    tiny_pokec.aggregate_min_max_avg();
+  });
+}

data/ext/gqliterb/vendor/gqlitedb/benches/pokec_iai.rs

@@ -0,0 +1,122 @@
+use std::hint::black_box;
+
+use iai_callgrind::{library_benchmark, library_benchmark_group, main};
+use rand::{rngs::StdRng, SeedableRng};
+
+mod common;
+
+use common::pokec::{Pokec, PokecSize};
+
+fn load_pokec(backend: &str) -> Pokec
+{
+  Pokec::load(backend, PokecSize::Micro)
+}
+
+fn load_with_ids(backend: &str) -> Pokec
+{
+  load_pokec(backend).read_ids()
+}
+
+#[library_benchmark]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn import_micro_pokec(backend: &str)
+{
+  black_box(load_pokec(backend));
+}
+
+#[library_benchmark(setup = load_with_ids)]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn single_vertex(micro_pokec: Pokec)
+{
+  let mut rng = StdRng::seed_from_u64(991173);
+  micro_pokec.single_vertex(&mut rng);
+}
+
+#[library_benchmark(setup = load_with_ids)]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn single_vertex_where(micro_pokec: Pokec)
+{
+  let mut rng = StdRng::seed_from_u64(991173);
+  micro_pokec.single_vertex_where(&mut rng);
+}
+
+#[library_benchmark(setup = load_with_ids)]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn friend_of(micro_pokec: Pokec)
+{
+  let mut rng = StdRng::seed_from_u64(991173);
+  micro_pokec.friend_of(&mut rng);
+}
+
+#[library_benchmark(setup = load_with_ids)]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn friend_of_filter(micro_pokec: Pokec)
+{
+  let mut rng = StdRng::seed_from_u64(991173);
+  micro_pokec.friend_of_filter(&mut rng);
+}
+
+#[library_benchmark(setup = load_with_ids)]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn friend_of_friend_of(micro_pokec: Pokec)
+{
+  let mut rng = StdRng::seed_from_u64(991173);
+  micro_pokec.friend_of_friend_of(&mut rng);
+}
+
+#[library_benchmark(setup = load_with_ids)]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn friend_of_friend_of_filter(micro_pokec: Pokec)
+{
+  let mut rng = StdRng::seed_from_u64(991173);
+  micro_pokec.friend_of_friend_of_filter(&mut rng);
+}
+
+#[library_benchmark(setup = load_with_ids)]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn reciprocal_friends(micro_pokec: Pokec)
+{
+  let mut rng = StdRng::seed_from_u64(991173);
+  micro_pokec.reciprocal_friends(&mut rng);
+}
+
+#[library_benchmark(setup = load_pokec)]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn aggregate_count(micro_pokec: Pokec)
+{
+  micro_pokec.aggregate_count();
+}
+
+#[library_benchmark(setup = load_pokec)]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn aggregate_count_filter(micro_pokec: Pokec)
+{
+  micro_pokec.aggregate_count_filter();
+}
+
+#[library_benchmark(setup = load_pokec)]
+#[bench::redb("redb")]
+#[bench::sqlite("sqlite")]
+fn aggregate_min_max_avg(micro_pokec: Pokec)
+{
+  micro_pokec.aggregate_min_max_avg();
+}
+
+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
+);
+
+main!(
+  setup = common::get_bench_data(); 
+  library_benchmark_groups = bench_micro_pokec_group);

data/ext/gqliterb/vendor/gqlitedb/release.toml

@@ -0,0 +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 = "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 },
+]

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

@@ -0,0 +1,96 @@
+use std::fmt::Debug;
+
+use super::AggregatorState;
+
+use crate::{error::RunTimeError, value::Value, Result};
+
+trait Op
+{
+  fn op_i64(a: i64, b: i64) -> i64;
+  fn op_f64(a: f64, b: f64) -> f64;
+}
+
+#[derive(Debug)]
+struct OpState<T>
+where
+  T: Op + Debug,
+{
+  value: Value,
+  _marker: std::marker::PhantomData<T>,
+}
+
+impl<T> OpState<T>
+where
+  T: Op + Debug,
+{
+  fn new() -> Result<Self>
+  {
+    Ok(Self {
+      value: Value::Null,
+      _marker: Default::default(),
+    })
+  }
+}
+
+impl<T> AggregatorState for OpState<T>
+where
+  T: Op + Debug,
+{
+  fn next(&mut self, value: Value) -> crate::Result<()>
+  {
+    match self.value
+    {
+      Value::Boolean(..)
+      | Value::Node(..)
+      | Value::Edge(..)
+      | Value::Array(..)
+      | Value::String(..)
+      | Value::Map(..)
+      | Value::Path(..) => Err(RunTimeError::InvalidBinaryOperands)?,
+      Value::Null =>
+      {
+        self.value = value;
+      }
+      Value::Float(state) => match value
+      {
+        Value::Null =>
+        {}
+        Value::Float(new_value) => self.value = T::op_f64(state, new_value).into(),
+        Value::Integer(new_value) => self.value = T::op_f64(state, new_value as f64).into(),
+        _ => Err(RunTimeError::InvalidBinaryOperands)?,
+      },
+      Value::Integer(state) => match value
+      {
+        Value::Null =>
+        {}
+        Value::Float(new_value) => self.value = T::op_f64(state as f64, new_value).into(),
+        Value::Integer(new_value) => self.value = T::op_i64(state, new_value).into(),
+        _ => Err(RunTimeError::InvalidBinaryOperands)?,
+      },
+    }
+    Ok(())
+  }
+  fn finalise(self: Box<Self>) -> crate::Result<crate::value::Value>
+  {
+    Ok(self.value)
+  }
+}
+
+#[derive(Debug)]
+struct SumOp;
+
+impl Op for SumOp
+{
+  fn op_f64(a: f64, b: f64) -> f64
+  {
+    a + b
+  }
+  fn op_i64(a: i64, b: i64) -> i64
+  {
+    a + b
+  }
+}
+
+type SumState = OpState<SumOp>;
+
+super::declare_aggregator!(sum, Sum, SumState, () -> i64);