gqlite 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b7eba40745af114ff57ca358b2e03c67a7adb9717ad7c7b81ddd7444503fbb1
-  data.tar.gz: 3ae6e7c7b038a2caeaf728ff7ce98c49266160d181f478c8259b98d7d8157ba5
+  metadata.gz: 5aac591ce0775f004fc859b9cd453a940d39f9f80aa1535e2a37aae948b6baac
+  data.tar.gz: c66e83597f70d3c69ed412d5431530d1c2cc211507b68c18c7df74b65da017ef
 SHA512:
-  metadata.gz: 6674d35ca4d0ec02090ef1521f9f8bb2a4025a050ed312e9c20d50033c8a3472a6a31bdb73dfe6fa9ec99612518c5f5edd72d3ea9d8ead7885c39ed106ac6056
-  data.tar.gz: e200b7d2a4203cf803a65bcd6eef82a990fc8c1fa2e2846148673109731353898dacd7b388fe23c9c5b8e5eeae2b56768912408f6f916805111d322c0a83d5ac
+  metadata.gz: 32503eae6aec73407846b1cce09f58374445473ef59122efe87280b4b756118d202199fc07da0b2ae7dd906f457997aac7b27d47eb17e490ce9c1a648c4e76cf
+  data.tar.gz: 95f14af4c49792144d5efa84ccc906c9d49ac065d808d927858d3d3a448ece3aa3137b1ece5057bb5b3534b301dd839e159a4fb745af0265efb352255c36d5c0

data/ext/Cargo.toml

@@ -3,19 +3,20 @@ resolver = "2"
 members = ["gqliterb", "gqlitedb", "graphcore"]
 
 [workspace.package]
-version = "0.7.0"
+version = "0.8.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://gqlite.org"
 repository = "https://gitlab.com/gqlite/gqlite"
 
 [workspace.dependencies]
-graphcore = { version = "0.7.0", path = "graphcore" }
-gqlitedb = { version = "0.7.0", path = "gqlitedb" }
+graphcore = { version = "0.8.0", path = "graphcore" }
+gqlitedb = { version = "0.8.0", path = "gqlitedb" }
 
-askama = { version = "0.14" }
+askama = { version = "0.15" }
 ccutils = { version = "0.4" }
 itertools = "0.14"
+rusqlite = { version = "0.37" }
 serde = "1"
 thiserror = "2"
 uuid = { version = "1", features = ["v4"] }

data/ext/gqlitedb/Cargo.toml

@@ -12,7 +12,7 @@ repository.workspace = true
 crate-type = ["cdylib", "lib"]
 
 [features]
-default = ["redb", "capi", "sqlite"]
+default = ["capi", "redb"]
 _backtrace = []
 capi = []
 redb = ["dep:redb", "dep:redb2"]
@@ -22,10 +22,9 @@ _pg14 = ["pgrx/pg14"]
 _pg15 = ["pgrx/pg15"]
 _pg16 = ["pgrx/pg16"]
 _pg17 = ["pgrx/pg17"]
-postgres = ["dep:postgres"]
+postgres = ["dep:postgres", "dep:askama"]
 sqlite = ["dep:rusqlite", "dep:askama"]
-_value_private = []
-bundled = ["rusqlite/bundled"]
+_cmake = ["postgres", "redb", "sqlite"]
 
 [dependencies]
 graphcore = { workspace = true }
@@ -37,11 +36,14 @@ itertools = { workspace = true }
 pest = "2"
 pest_derive = "2"
 pgrx = { version = "0.16", optional = true }
-postgres = { version = "0.19", optional = true }
+postgres = { version = "0.19", optional = true, features = [
+  "with-uuid-1",
+  "with-serde_json-1",
+] }
 rand = "0.9"
 redb = { version = "3", optional = true }
 redb2 = { version = "2", optional = true, package = "redb" }
-rusqlite = { package = "rusqlite", version = "0.37", optional = true, features = [
+rusqlite = { workspace = true, optional = true, features = [
   "functions",
   "uuid",
 ] }
@@ -54,9 +56,11 @@ uuid = { workspace = true }
 ccutils = { workspace = true, features = ["alias", "temporary"] }
 divan = "0.1"
 iai-callgrind = { version = "0.16" }
-pgtemp = "0.6"
 regex = "1"
 
+[target.'cfg(not(windows))'.dev-dependencies]
+pgtemp = "0.7"
+
 # 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 = [
@@ -71,6 +75,9 @@ uuid = { version = "1", features = ["js"] }
 #   "uuid",
 # ] }
 
+[target.'cfg(windows)'.dependencies]
+rusqlite = { workspace = true, features = ["bundled"] }
+
 [[bench]]
 name = "pokec_divan"
 harness = false

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

@@ -5,10 +5,15 @@ use gqlitedb::{value_map, Connection};
 use rand::{seq::IndexedRandom, Rng};
 use regex::Regex;
 
+/// Marker trait to keep backend-specific resources alive for the benchmark lifetime.
+trait BackendResource {}
+impl BackendResource for TemporaryFile {}
+impl BackendResource for pgtemp::PgTempDB {}
+
 pub(crate) struct Pokec
 {
   #[allow(dead_code)]
-  temporary_file: TemporaryFile,
+  file_handle: Box<dyn BackendResource>,
   connection: Connection,
   ids: Vec<i64>,
 }
@@ -28,17 +33,64 @@ impl Pokec
     {
       "sqlite" => gqlitedb::Backend::SQLite,
       "redb" => gqlitedb::Backend::Redb,
+      "postgres" => gqlitedb::Backend::Postgres,
       o => panic!("Unknown backend '{}'", o),
     };
-    let temporary_file = TemporaryFile::builder()
-      .should_create_file(false)
-      .label("gqlite_bench")
-      .create();
-    let connection = Connection::builder()
-      .path(temporary_file.path())
-      .backend(backend)
-      .create()
-      .unwrap();
+    let (file_handle, connection): (Box<dyn BackendResource>, _) = match backend
+    {
+      gqlitedb::Backend::Redb | gqlitedb::Backend::SQLite =>
+      {
+        let temporary_file = TemporaryFile::builder()
+          .should_create_file(false)
+          .label("gqlite_bench")
+          .create();
+        let connection = Connection::builder()
+          .path(temporary_file.path())
+          .backend(backend)
+          .create()
+          .unwrap();
+        (Box::new(temporary_file), connection)
+      }
+      gqlitedb::Backend::Postgres =>
+      {
+        use std::{
+          thread::sleep,
+          time::{Duration, Instant},
+        };
+        let output = std::process::Command::new("pg_config")
+          .arg("--bindir")
+          .output()
+          .expect("failed to execute pg_config");
+
+        let bin_path = String::from_utf8_lossy(&output.stdout).trim().to_string();
+
+        let db = pgtemp::PgTempDB::builder().with_bin_path(bin_path).start();
+
+        const MAX_WAIT: Duration = Duration::from_secs(30);
+        const INTERVAL: Duration = Duration::from_secs(1);
+
+        let deadline = Instant::now() + MAX_WAIT;
+
+        let mut connection = Connection::builder()
+          .set_option("url", db.connection_uri())
+          .backend(backend)
+          .create();
+        while connection.is_err() && Instant::now() < deadline
+        {
+          sleep(INTERVAL);
+          connection = Connection::builder()
+            .set_option("url", db.connection_uri())
+            .backend(backend)
+            .create()
+        }
+        let connection = connection.expect("Failed to connect to temporary Postgres DB within 30s");
+        (Box::new(db), connection)
+      }
+      gqlitedb::Backend::Automatic =>
+      {
+        panic!("Should not be selected.")
+      }
+    };
 
     let filename = match size
     {
@@ -52,7 +104,7 @@ impl Pokec
       .execute_oc_query(import_query, Default::default())
       .unwrap();
     Self {
-      temporary_file,
+      file_handle,
       connection,
       ids: Default::default(),
     }

data/ext/gqlitedb/benches/pokec_divan.rs

@@ -23,13 +23,13 @@ fn load_pokec(backend: &str) -> Pokec
 }
 
 // Import the tiny `pokec` dataset.
-#[divan::bench(args = ["sqlite", "redb"], sample_count = IMPORT_COUNT)]
+#[divan::bench(args = ["postgres", "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)]
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = SINGLE_VERTEX_COUNT)]
 fn single_vertex(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend).read_ids();
@@ -40,7 +40,7 @@ fn single_vertex(bencher: Bencher, backend: &str)
   });
 }
 
-#[divan::bench(args = ["sqlite", "redb"], sample_count = SINGLE_VERTEX_COUNT)]
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = SINGLE_VERTEX_COUNT)]
 fn single_vertex_where(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend).read_ids();
@@ -51,7 +51,7 @@ fn single_vertex_where(bencher: Bencher, backend: &str)
   });
 }
 
-#[divan::bench(args = ["sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
 fn friend_of(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend).read_ids();
@@ -62,7 +62,7 @@ fn friend_of(bencher: Bencher, backend: &str)
   });
 }
 
-#[divan::bench(args = ["sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
 fn friend_of_filter(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend).read_ids();
@@ -73,7 +73,7 @@ fn friend_of_filter(bencher: Bencher, backend: &str)
   });
 }
 
-#[divan::bench(args = ["sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
 fn friend_of_friend_of(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend).read_ids();
@@ -84,7 +84,7 @@ fn friend_of_friend_of(bencher: Bencher, backend: &str)
   });
 }
 
-#[divan::bench(args = ["sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
+#[divan::bench(args = ["postgres", "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();
@@ -95,7 +95,7 @@ fn friend_of_friend_of_filter(bencher: Bencher, backend: &str)
   });
 }
 
-#[divan::bench(args = ["sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
 fn reciprocal_friends(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend).read_ids();
@@ -106,7 +106,7 @@ fn reciprocal_friends(bencher: Bencher, backend: &str)
   });
 }
 
-#[divan::bench(args = ["sqlite", "redb"])]
+#[divan::bench(args = ["postgres", "sqlite", "redb"])]
 fn aggregate_count(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend);
@@ -116,7 +116,7 @@ fn aggregate_count(bencher: Bencher, backend: &str)
   });
 }
 
-#[divan::bench(args = ["sqlite", "redb"])]
+#[divan::bench(args = ["postgres", "sqlite", "redb"])]
 fn aggregate_count_filter(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend);
@@ -126,7 +126,7 @@ fn aggregate_count_filter(bencher: Bencher, backend: &str)
   });
 }
 
-#[divan::bench(args = ["sqlite", "redb"])]
+#[divan::bench(args = ["postgres", "sqlite", "redb"])]
 fn aggregate_min_max_avg(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend);

data/ext/gqlitedb/benches/pokec_iai.rs

@@ -18,6 +18,7 @@ fn load_with_ids(backend: &str) -> Pokec
 }
 
 #[library_benchmark]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn import_micro_pokec(backend: &str)
@@ -26,6 +27,7 @@ fn import_micro_pokec(backend: &str)
 }
 
 #[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn single_vertex(micro_pokec: Pokec)
@@ -35,6 +37,7 @@ fn single_vertex(micro_pokec: Pokec)
 }
 
 #[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn single_vertex_where(micro_pokec: Pokec)
@@ -44,6 +47,7 @@ fn single_vertex_where(micro_pokec: Pokec)
 }
 
 #[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn friend_of(micro_pokec: Pokec)
@@ -53,6 +57,7 @@ fn friend_of(micro_pokec: Pokec)
 }
 
 #[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn friend_of_filter(micro_pokec: Pokec)
@@ -62,6 +67,7 @@ fn friend_of_filter(micro_pokec: Pokec)
 }
 
 #[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn friend_of_friend_of(micro_pokec: Pokec)
@@ -71,6 +77,7 @@ fn friend_of_friend_of(micro_pokec: Pokec)
 }
 
 #[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn friend_of_friend_of_filter(micro_pokec: Pokec)
@@ -80,6 +87,7 @@ fn friend_of_friend_of_filter(micro_pokec: Pokec)
 }
 
 #[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn reciprocal_friends(micro_pokec: Pokec)
@@ -89,6 +97,7 @@ fn reciprocal_friends(micro_pokec: Pokec)
 }
 
 #[library_benchmark(setup = load_pokec)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn aggregate_count(micro_pokec: Pokec)
@@ -97,6 +106,7 @@ fn aggregate_count(micro_pokec: Pokec)
 }
 
 #[library_benchmark(setup = load_pokec)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn aggregate_count_filter(micro_pokec: Pokec)
@@ -105,6 +115,7 @@ fn aggregate_count_filter(micro_pokec: Pokec)
 }
 
 #[library_benchmark(setup = load_pokec)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn aggregate_min_max_avg(micro_pokec: Pokec)

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

@@ -21,7 +21,10 @@ impl AggregatorState for CollectState
 {
   fn next(&mut self, value: Value) -> crate::Result<()>
   {
-    self.value.push(value);
+    if !value.is_null()
+    {
+      self.value.push(value);
+    }
     Ok(())
   }
   fn finalise(self: Box<Self>) -> crate::Result<crate::value::Value>

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

@@ -144,3 +144,132 @@ impl AggregatorState for MaxState
 }
 
 super::declare_aggregator!(max, Max, MaxState, () -> i64);
+
+#[derive(Debug)]
+struct PercentileDiscState
+{
+  values: Vec<f64>,
+  percentile: f64,
+}
+
+impl PercentileDiscState
+{
+  fn new(percentile: value::Value) -> Result<Self>
+  {
+    Ok(Self {
+      values: Default::default(),
+      percentile: percentile.try_into()?,
+    })
+  }
+}
+
+impl AggregatorState for PercentileDiscState
+{
+  fn next(&mut self, value: value::Value) -> crate::Result<()>
+  {
+    if !value.is_null()
+    {
+      self.values.push(value.try_into()?);
+    }
+    Ok(())
+  }
+  fn finalise(self: Box<Self>) -> crate::Result<crate::value::Value>
+  {
+    if !self.percentile.is_finite() || !(0.0..=1.0).contains(&self.percentile)
+    {
+      return Err(
+        RunTimeError::NumberOutOfRange {
+          value: self.percentile,
+          min: 0.0,
+          max: 1.0,
+        }
+        .into(),
+      );
+    }
+
+    if self.values.is_empty()
+    {
+      return Ok(0.0.into());
+    }
+
+    let mut sorted = self.values;
+    sorted.sort_by(|a, b| a.total_cmp(b));
+
+    let n = sorted.len() as f64;
+    let index = (self.percentile * (n - 1.0)).round() as usize;
+
+    Ok(sorted[index].into())
+  }
+}
+
+super::declare_aggregator!(percentiledisc, PercentileDisc, PercentileDiscState, (value::Value) -> f64);
+
+#[derive(Debug)]
+struct PercentileContState
+{
+  values: Vec<f64>,
+  percentile: f64,
+}
+
+impl PercentileContState
+{
+  fn new(percentile: value::Value) -> Result<Self>
+  {
+    Ok(Self {
+      values: Default::default(),
+      percentile: percentile.try_into()?,
+    })
+  }
+}
+
+impl AggregatorState for PercentileContState
+{
+  fn next(&mut self, value: value::Value) -> crate::Result<()>
+  {
+    if !value.is_null()
+    {
+      self.values.push(value.try_into()?);
+    }
+    Ok(())
+  }
+  fn finalise(self: Box<Self>) -> crate::Result<crate::value::Value>
+  {
+    if !self.percentile.is_finite() || !(0.0..=1.0).contains(&self.percentile)
+    {
+      return Err(
+        RunTimeError::NumberOutOfRange {
+          value: self.percentile,
+          min: 0.0,
+          max: 1.0,
+        }
+        .into(),
+      );
+    }
+
+    if self.values.is_empty()
+    {
+      return Ok(0.0.into());
+    }
+
+    let mut sorted = self.values;
+    sorted.sort_by(|a, b| a.total_cmp(b));
+
+    let n = sorted.len() as f64;
+    let pos = self.percentile * (n - 1.0);
+    let lower_index = pos.floor() as usize;
+    let upper_index = lower_index + 1;
+
+    if lower_index >= sorted.len() - 1
+    {
+      return Ok(sorted[sorted.len() - 1].into());
+    }
+
+    let weight = pos - pos.floor();
+    let lower = sorted[lower_index];
+    let upper = sorted[upper_index];
+
+    Ok((lower + weight * (upper - lower)).into())
+  }
+}
+
+super::declare_aggregator!(percentilecont, PercentileCont, PercentileContState, (value::Value) -> f64);

data/ext/gqlitedb/src/aggregators.rs

@@ -69,6 +69,8 @@ pub(crate) fn init_aggregators() -> std::collections::HashMap<String, Aggregator
     stats::Avg::create(),
     stats::Min::create(),
     stats::Max::create(),
+    stats::PercentileDisc::create(),
+    stats::PercentileCont::create(),
   ]
   .into()
 }

data/ext/gqlitedb/src/connection.rs

@@ -4,6 +4,7 @@ use crate::{prelude::*, QueryResult};
 use value::ValueTryIntoRef;
 
 /// Backend
+#[derive(Debug, Clone, Copy)]
 pub enum Backend
 {
   /// Select the first available backend.
@@ -28,12 +29,16 @@ pub struct ConnectionBuilder
 impl ConnectionBuilder
 {
   /// Merge options. This might overwrite value from the builder
-  pub fn options(mut self, options: value::ValueMap) -> Self
+  pub fn options(mut self, options: impl Into<value::ValueMap>) -> Self
   {
-    for (k, v) in options.into_iter()
-    {
-      self.map.insert(k, v);
-    }
+    let mut options = options.into();
+    self.map.extend(options.drain());
+    self
+  }
+  /// Set the option value for the given key.
+  pub fn set_option(mut self, key: impl Into<String>, value: impl Into<value::Value>) -> Self
+  {
+    self.map.insert(key.into(), value.into());
     self
   }
   /// Set path
@@ -263,6 +268,10 @@ impl Connection
       "postgres" =>
       {
         let mut config = postgres::Config::new();
+        if let Some(url) = options.get("url")
+        {
+          config = url.to_string().parse()?;
+        }
         if let Some(host) = options.get("host")
         {
           let host: &String = host.try_into_ref()?;
@@ -283,7 +292,8 @@ impl Connection
           connection: ConnectionImpl {
             store,
             function_manager: functions::Manager::new(),
-          },
+          }
+          .boxed(),
         })
       }
       _ => Err(StoreError::UnknownBackend { backend }.into()),

data/ext/gqlitedb/src/error.rs

@@ -162,6 +162,11 @@ pub enum RunTimeError
   },
   #[error("Path cannot have null key.")]
   MissingKey,
+  #[error("NumberOutOfRange: expected a value between {min} and {max}, got {value}.")]
+  NumberOutOfRange
+  {
+    value: f64, min: f64, max: f64
+  },
 }
 
 /// Internal errors, should be treated as bugs.
@@ -336,6 +341,22 @@ pub enum StoreError
   #[error("redb: {0}")]
   Redb2Error(#[from] redb2::Error),
 
+  #[cfg(feature = "postgres")]
+  #[error("Postgres: {0}")]
+  PostgresError(#[from] postgres::Error),
+
+  #[cfg(feature = "postgres")]
+  #[error("Postgres: {error} while executing {query}.")]
+  PostgresErrorWithQuery
+  {
+    error: postgres::Error,
+    query: String,
+  },
+
+  #[cfg(feature = "postgres")]
+  #[error("Postgres: unsupported type {0}")]
+  UnsupportedPostgresType(String),
+
   #[error("UnknownBackend: backend '{backend}' is unknown.")]
   UnknownBackend
   {
@@ -522,8 +543,6 @@ macro_rules! error_as_internal {
   };
 }
 
-pub(crate) use error_as_internal;
-
 macro_rules! error_as_store {
   ($err_type:ty) => {
     impl From<$err_type> for crate::prelude::ErrorType
@@ -588,6 +607,17 @@ mod _trait_impl_redb
 mod _trait_impl_sqlite
 {
   error_as_store! {rusqlite::Error}
+}
+
+#[cfg(feature = "postgres")]
+mod _trait_impl_postgres
+{
+  error_as_store! {postgres::Error}
+}
+
+#[cfg(any(feature = "postgres", feature = "sqlite"))]
+mod _trait_impl_askama
+{
   error_as_internal! {askama::Error}
 }
 

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

@@ -6,8 +6,7 @@ pub(super) struct Head {}
 
 impl Head
 {
-  #[allow(clippy::ptr_arg)]
-  fn call_impl(array: &Vec<value::Value>) -> FResult<value::Value>
+  fn call_impl(array: Vec<value::Value>) -> FResult<value::Value>
   {
     Ok(
       array
@@ -30,7 +29,7 @@ pub(super) struct Keys {}
 
 impl Keys
 {
-  fn call_impl(container: &value::Value) -> Result<Vec<value::Value>>
+  fn call_impl(container: value::Value) -> Result<Vec<value::Value>>
   {
     match container
     {
@@ -57,9 +56,9 @@ pub(super) struct Range {}
 
 impl Range
 {
-  fn call_impl(min: &i64, max: &i64) -> FResult<Vec<i64>>
+  fn call_impl(min: i64, max: i64) -> FResult<Vec<i64>>
   {
-    Ok((*min..=*max).step_by(1).collect())
+    Ok((min..=max).step_by(1).collect())
   }
 }
 

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

@@ -7,7 +7,7 @@ pub(super) struct Type {}
 
 impl Type
 {
-  fn call_impl(edge: &graph::Edge) -> FResult<String>
+  fn call_impl(edge: graph::Edge) -> FResult<String>
   {
     edge
       .labels()