gqlite 1.5.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5aac591ce0775f004fc859b9cd453a940d39f9f80aa1535e2a37aae948b6baac
-  data.tar.gz: c66e83597f70d3c69ed412d5431530d1c2cc211507b68c18c7df74b65da017ef
+  metadata.gz: 34702a81803ce382efb13f4206de1f1ba73329cd0a3ffe52238d32eb979a427a
+  data.tar.gz: e9ccb531863f44072f0d6e58102296b32c54ad0f071772da755d031836d44b78
 SHA512:
-  metadata.gz: 32503eae6aec73407846b1cce09f58374445473ef59122efe87280b4b756118d202199fc07da0b2ae7dd906f457997aac7b27d47eb17e490ce9c1a648c4e76cf
-  data.tar.gz: 95f14af4c49792144d5efa84ccc906c9d49ac065d808d927858d3d3a448ece3aa3137b1ece5057bb5b3534b301dd839e159a4fb745af0265efb352255c36d5c0
+  metadata.gz: 4cdf5b62762da1c470888c26d950e39e1843c91825f96b0a5cf4e6d39c4a26e981f16a6cef13153c21781996189569895310b758469d35777f0f71c56b7748ee
+  data.tar.gz: '07697d27aea70038327f849f70231568824cd5a2b6a539eb4567476cf9def21f01469003050ec14ce5626e4b603dfdf5db79b9ab631267dc500672ab21c4f8ab'

data/ext/Cargo.toml

@@ -1,10 +1,10 @@
 [workspace]
-resolver = "2"
+resolver = "3"
 members = ["gqliterb", "gqlitedb", "graphcore"]
 
 [workspace.package]
 version = "0.8.0"
-edition = "2021"
+edition = "2024"
 license = "MIT"
 homepage = "https://gqlite.org"
 repository = "https://gitlab.com/gqlite/gqlite"

data/ext/gqlitedb/Cargo.toml

@@ -51,6 +51,7 @@ serde = { workspace = true }
 serde_json = "1"
 thiserror = { workspace = true }
 uuid = { workspace = true }
+substring = "1"
 
 [dev-dependencies]
 ccutils = { workspace = true, features = ["alias", "temporary"] }

data/ext/gqlitedb/src/capi.rs

@@ -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/variables_manager.rs

@@ -572,16 +572,14 @@ impl VariablesManager
         for pattern in create.patterns.iter()
         {
           if let ast::Pattern::Node(n) = &pattern
+            && self.has_variable(&n.variable)
           {
-            if self.has_variable(&n.variable)
-            {
-              return Err(
-                CompileTimeError::VariableAlreadyBound {
-                  name: n.variable.clone().unwrap().name().clone(),
-                }
-                .into(),
-              );
-            }
+            return Err(
+              CompileTimeError::VariableAlreadyBound {
+                name: n.variable.clone().unwrap().name().clone(),
+              }
+              .into(),
+            );
           }
           self.analyse_pattern(pattern, true)?;
         }

data/ext/gqlitedb/src/compiler.rs

@@ -938,7 +938,7 @@ pub(crate) fn compile(
     .map(|stmt| {
       compiler.temporary_variables = 0;
       compiler.variables_manager.analyse(stmt)?;
-      let inst = match stmt
+      match stmt
       {
         ast::Statement::CreateGraph(create_graph) => Ok(Block::CreateGraph {
           name: create_graph.name.to_owned(),
@@ -1107,8 +1107,7 @@ pub(crate) fn compile(
             .collect::<Result<_>>()?,
           variables_size: compiler.variables_size(),
         }),
-      };
-      inst
+      }
     })
     .scan(&mut statements_err, |err, gp| {
       gp.map_err(|e| **err = Err(e)).ok()

data/ext/gqlitedb/src/connection.rs

@@ -319,6 +319,8 @@ impl Connection
       "sqlite".to_string(),
       #[cfg(feature = "redb")]
       "redb".to_string(),
+      #[cfg(feature = "postgres")]
+      "postgres".to_string(),
     ]
   }
 

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

@@ -0,0 +1,27 @@
+use super::FResult;
+use crate::prelude::*;
+
+#[derive(Debug, Default)]
+pub(super) struct Size {}
+
+impl Size
+{
+  fn call_impl(value: value::Value) -> FResult<i64>
+  {
+    match value
+    {
+      value::Value::String(str) => Ok(str.len() as i64),
+      value::Value::Array(arr) => Ok(arr.len() as i64),
+      value::Value::Map(obj) => Ok(obj.len() as i64),
+      value::Value::Path(..) => Ok(1.into()),
+      _ => Err(RunTimeError::InvalidArgument {
+        function_name: "size",
+        index: 0,
+        expected_type: "array, map or string",
+        value: format!("{:?}", value),
+      }),
+    }
+  }
+}
+
+super::declare_function!(size, Size, call_impl(graphcore::Value) -> i64, null_handling(null_returns_null));

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

@@ -21,7 +21,7 @@ super::declare_function!(
   head,
   Head,
   call_impl(Vec<crate::value::Value>) -> crate::value::Value,
-  accept_null
+  null_handling(null_returns_null)
 );
 
 #[derive(Debug, Default)]
@@ -49,7 +49,7 @@ impl Keys
   }
 }
 
-super::declare_function!(keys, Keys, call_impl(crate::value::Value) -> Vec<crate::value::Value>, validate_args(ExpressionType::Map | ExpressionType::Node | ExpressionType::Edge | ExpressionType::Null));
+super::declare_function!(keys, Keys, call_impl(crate::value::Value) -> Vec<crate::value::Value>, null_handling(null_returns_null), validate_args(ExpressionType::Map | ExpressionType::Node | ExpressionType::Edge | ExpressionType::Null));
 
 #[derive(Debug, Default)]
 pub(super) struct Range {}
@@ -63,47 +63,3 @@ impl Range
 }
 
 super::declare_function!(range, Range, call_impl(i64, i64) -> Vec<i64>);
-
-#[derive(Debug, Default)]
-pub(super) struct Size {}
-
-impl super::FunctionTrait for Size
-{
-  fn call(&self, arguments: Vec<value::Value>) -> Result<value::Value>
-  {
-    let container = arguments
-      .first()
-      .ok_or(RunTimeError::InvalidNumberOfArguments {
-        function_name: "size",
-        got: arguments.len(),
-        expected: 1,
-      })?;
-
-    match container
-    {
-      value::Value::Null => Ok(value::Value::Null),
-      value::Value::Array(arr) => Ok((arr.len() as i64).into()),
-      value::Value::Map(obj) => Ok((obj.len() as i64).into()),
-      value::Value::Path(..) => Ok(1.into()),
-      _ => Err(
-        RunTimeError::InvalidArgument {
-          function_name: "size",
-          index: 0,
-          expected_type: "array or map",
-          value: format!("{:?}", container),
-        }
-        .into(),
-      ),
-    }
-  }
-  fn validate_arguments(&self, _: Vec<ExpressionType>) -> Result<ExpressionType>
-  {
-    Ok(ExpressionType::Variant)
-  }
-  fn is_deterministic(&self) -> bool
-  {
-    true
-  }
-}
-
-super::declare_function!(size, Size, custom_trait);

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

@@ -17,4 +17,4 @@ impl Type
   }
 }
 
-super::declare_function!(type, Type, call_impl(crate::graph::Edge) -> String);
+super::declare_function!(type, Type, call_impl(crate::graph::Edge) -> String, null_handling(null_returns_null));

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

@@ -4,6 +4,39 @@ use crate::prelude::*;
 
 use super::FResult;
 
+trait Extra
+{
+  fn cot(self) -> Self;
+}
+
+impl Extra for f64
+{
+  fn cot(self) -> Self
+  {
+    self.cos() / self.sin()
+  }
+}
+
+macro_rules! declare_constant {
+    ($name: ident, $class_name: ident, $rust_const: ident) => {
+      #[derive(Debug, Default)]
+      pub(super) struct $class_name {}
+
+      impl $class_name
+      {
+        fn call_impl() -> FResult<f64>
+        {
+          Ok(std::f64::consts::$rust_const)
+        }
+      }
+
+      super::declare_function!($name, $class_name, call_impl() -> f64);
+    };
+}
+
+declare_constant!(pi, Pi, PI);
+declare_constant!(e, E, E);
+
 #[derive(Debug, Default)]
 pub(super) struct Rand {}
 
@@ -17,28 +50,62 @@ impl Rand
 
 super::declare_function!(rand, Rand, call_impl() -> Vec<f64>);
 
+macro_rules! define_f64_function {
+    ($name: ident, $class_name: ident, $rust_func: ident $(, $arg0: expr)*) => {
+      #[derive(Debug, Default)]
+      pub(super) struct $class_name {}
+
+      impl $class_name
+      {
+        fn call_impl(value: f64) -> FResult<f64>
+        {
+          Ok(value.$rust_func($($arg0)*))
+        }
+      }
+
+      super::declare_function!($name, $class_name, call_impl(f64) -> f64);
+
+    };
+    ($name: ident, $class_name: ident) => {
+        define_f64_function!($name, $class_name, $name);
+    };
+}
+
+define_f64_function!(exp, Exp);
+define_f64_function!(log, Log, ln);
+define_f64_function!(log10, Log10, log10);
+define_f64_function!(sin, Sin);
+define_f64_function!(cos, Cos);
+define_f64_function!(tan, Tan);
+define_f64_function!(cot, Cot, cot);
+define_f64_function!(acos, Acos);
+define_f64_function!(asin, Asin);
+define_f64_function!(atan, Atan);
+define_f64_function!(floor, Floor);
+define_f64_function!(ceil, Ceil);
+define_f64_function!(degrees, Degrees, to_degrees);
+define_f64_function!(radians, Radians, to_radians);
+
 #[derive(Debug, Default)]
-pub(super) struct Ceil {}
+pub(super) struct Atan2 {}
 
-impl Ceil
+impl Atan2
 {
-  fn call_impl(value: f64) -> FResult<f64>
+  fn call_impl(x: f64, y: f64) -> FResult<f64>
   {
-    Ok(value.ceil())
+    Ok(x.atan2(y))
   }
 }
 
-super::declare_function!(ceil, Ceil, call_impl(f64) -> f64);
+super::declare_function!(atan2, Atan2, call_impl(f64, f64) -> f64);
 
-#[derive(Debug, Default)]
-pub(super) struct Floor {}
-
-impl Floor
+#[cfg(test)]
+mod test
 {
-  fn call_impl(value: f64) -> FResult<f64>
+  use crate::functions::math::Extra as _;
+  #[test]
+  fn test_cot()
   {
-    Ok(value.floor())
+    assert_eq!(0.5_f64.cot(), 1.830487721712452);
   }
 }
-
-super::declare_function!(floor, Floor, call_impl(f64) -> f64);

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

@@ -13,4 +13,4 @@ impl Labels
   }
 }
 
-super::declare_function!(labels, Labels, call_impl(crate::graph::Node) -> Vec<String>);
+super::declare_function!(labels, Labels, call_impl(crate::graph::Node) -> Vec<String>, null_handling(null_returns_null));

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

@@ -2,6 +2,34 @@ use crate::prelude::*;
 
 use super::{ExpressionType, FResult, FunctionTypeTrait};
 
+#[derive(Debug, Default)]
+pub(super) struct Abs {}
+
+impl Abs
+{
+  fn call_impl(value: value::Value) -> FResult<value::Value>
+  {
+    match value
+    {
+      value::Value::Integer(i) => Ok(i.abs().into()),
+      value::Value::Float(f) => Ok(f.abs().into()),
+      o => Err(RunTimeError::InvalidArgument {
+        function_name: "abs",
+        index: 0,
+        expected_type: "integer or float",
+        value: format!("{:?}", o),
+      }),
+    }
+  }
+}
+
+super::declare_function!(
+  abs, Abs,
+  call_impl(value::Value) -> value::Value,
+  null_handling(null_returns_null),
+  validate_args(ExpressionType::Integer | ExpressionType::Float)
+);
+
 #[derive(Debug, Default)]
 pub(super) struct Coalesce {}
 
@@ -82,7 +110,12 @@ impl ToBoolean
   }
 }
 
-super::declare_function!(toboolean, ToBoolean, call_impl(crate::value::Value) -> value::Value);
+super::declare_function!(
+  toboolean, ToBoolean,
+  call_impl(crate::value::Value) -> bool,
+  null_handling(null_returns_null),
+  validate_args(ExpressionType::Boolean | ExpressionType::Integer | ExpressionType::Float | ExpressionType::String)
+);
 
 #[derive(Debug, Default)]
 pub(super) struct ToFloat {}
@@ -110,7 +143,12 @@ impl ToFloat
   }
 }
 
-super::declare_function!(tofloat, ToFloat, call_impl(crate::value::Value) -> value::Value);
+super::declare_function!(
+  tofloat, ToFloat,
+  call_impl(crate::value::Value) -> f64,
+  null_handling(null_returns_null),
+  validate_args(ExpressionType::Boolean | ExpressionType::Integer | ExpressionType::Float | ExpressionType::String)
+);
 
 #[derive(Debug, Default)]
 pub(super) struct ToInteger {}
@@ -138,7 +176,12 @@ impl ToInteger
   }
 }
 
-super::declare_function!(tointeger, ToInteger, call_impl(crate::value::Value) -> value::Value);
+super::declare_function!(
+  tointeger, ToInteger,
+  call_impl(crate::value::Value) -> i64,
+  null_handling(null_returns_null),
+  validate_args(ExpressionType::Boolean | ExpressionType::Integer | ExpressionType::Float | ExpressionType::String)
+);
 
 #[derive(Debug, Default)]
 pub(super) struct Properties {}
@@ -162,4 +205,4 @@ impl Properties
   }
 }
 
-super::declare_function!(properties, Properties, call_impl(crate::value::Value) -> value::ValueMap, validate_args(ExpressionType::Map | ExpressionType::Node | ExpressionType::Edge | ExpressionType::Null));
+super::declare_function!(properties, Properties, call_impl(crate::value::Value) -> value::ValueMap, null_handling(null_returns_null), validate_args(ExpressionType::Map | ExpressionType::Node | ExpressionType::Edge | ExpressionType::Null));

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

@@ -2,6 +2,123 @@ use crate::prelude::*;
 
 use super::{ExpressionType, FResult, FunctionTypeTrait};
 
+#[derive(Debug, Default)]
+pub(super) struct ToLower {}
+
+impl ToLower
+{
+  fn call_impl(string: String) -> FResult<String>
+  {
+    Ok(string.to_lowercase())
+  }
+}
+
+super::declare_function!(tolower, ToLower, call_impl(String) -> String, null_handling(null_returns_null));
+
+#[derive(Debug, Default)]
+pub(super) struct ToUpper {}
+
+impl ToUpper
+{
+  fn call_impl(string: String) -> FResult<String>
+  {
+    Ok(string.to_uppercase())
+  }
+}
+
+super::declare_function!(toupper, ToUpper, call_impl(String) -> String, null_handling(null_returns_null));
+
+#[derive(Debug, Default)]
+pub(super) struct LTrim {}
+
+impl LTrim
+{
+  fn call_impl(string: String) -> FResult<String>
+  {
+    Ok(string.trim_start().to_string())
+  }
+}
+
+super::declare_function!(ltrim, LTrim, call_impl(String) -> String, null_handling(null_returns_null));
+
+#[derive(Debug, Default)]
+pub(super) struct RTrim {}
+
+impl RTrim
+{
+  fn call_impl(string: String) -> FResult<String>
+  {
+    Ok(string.trim_end().to_string())
+  }
+}
+
+super::declare_function!(rtrim, RTrim, call_impl(String) -> String, null_handling(null_returns_null));
+
+#[derive(Debug, Default)]
+pub(super) struct Trim {}
+
+impl Trim
+{
+  fn call_impl(string: String) -> FResult<String>
+  {
+    Ok(string.trim().to_string())
+  }
+}
+
+super::declare_function!(trim, Trim, call_impl(String) -> String, null_handling(null_returns_null));
+
+#[derive(Debug, Default)]
+pub(super) struct Reverse {}
+
+impl Reverse
+{
+  fn call_impl(string: String) -> FResult<String>
+  {
+    Ok(string.chars().rev().collect())
+  }
+}
+
+super::declare_function!(reverse, Reverse, call_impl(String) -> String, null_handling(null_returns_null));
+
+#[derive(Debug, Default)]
+pub(super) struct Split {}
+
+impl Split
+{
+  fn call_impl(string: String, pat: String) -> FResult<Vec<graphcore::Value>>
+  {
+    Ok(string.split(&pat).map(|x: &str| x.into()).collect())
+  }
+}
+
+super::declare_function!(
+  split, Split, call_impl(String, String) -> String,
+  null_handling(null_returns_null, ignore, ignore)
+);
+
+#[derive(Debug, Default)]
+pub(super) struct Substring {}
+
+impl Substring
+{
+  fn call_impl(string: String, start: i64, length: i64) -> FResult<String>
+  {
+    use substring::Substring;
+    Ok(
+      string
+        .substring(start as usize, length as usize)
+        .to_string(),
+    )
+  }
+}
+
+super::declare_function!(
+  substring, Substring, call_impl(String, i64, i64) -> String,
+  null_handling(null_returns_null, ignore, ignore),
+  validate_args(ExpressionType::String | ExpressionType::Null, ExpressionType::Integer, ExpressionType::Integer),
+  default_args(2, i64::MAX)
+);
+
 #[derive(Debug, Default)]
 pub(super) struct ToString {}
 
@@ -25,4 +142,9 @@ impl ToString
   }
 }
 
-super::declare_function!(tostring, ToString, call_impl(crate::value::Value) -> String, validate_args(ExpressionType::Boolean | ExpressionType::Integer | ExpressionType::Float | ExpressionType::String | ExpressionType::Null));
+super::declare_function!(
+  tostring, ToString,
+  call_impl(crate::value::Value) -> String,
+  null_handling(null_returns_null),
+  validate_args(ExpressionType::Boolean | ExpressionType::Integer | ExpressionType::Float | ExpressionType::String)
+);

data/ext/gqlitedb/src/functions.rs

@@ -1,5 +1,6 @@
 use std::{collections::HashMap, fmt::Debug, sync::Arc};
 
+mod common;
 mod containers;
 mod edge;
 mod math;
@@ -140,24 +141,48 @@ impl Manager
     Self {
       inner: ManagerInner {
         functions: HashMap::from([
+          common::Size::create(),
           containers::Head::create(),
           containers::Keys::create(),
           containers::Range::create(),
-          containers::Size::create(),
           edge::Type::create(),
+          math::Acos::create(),
+          math::Asin::create(),
+          math::Atan::create(),
+          math::Atan2::create(),
           math::Ceil::create(),
+          math::Cos::create(),
+          math::Cot::create(),
+          math::Degrees::create(),
+          math::E::create(),
+          math::Exp::create(),
           math::Floor::create(),
+          math::Log::create(),
+          math::Log10::create(),
+          math::Pi::create(),
+          math::Radians::create(),
           math::Rand::create(),
+          math::Sin::create(),
+          math::Tan::create(),
           node::Labels::create(),
           path::Length::create(),
           path::Nodes::create(),
           path::Edges::create(),
+          scalar::Abs::create(),
           scalar::Coalesce::create(),
           scalar::Id::create(),
           scalar::Properties::create(),
           scalar::ToBoolean::create(),
           scalar::ToFloat::create(),
           scalar::ToInteger::create(),
+          string::LTrim::create(),
+          string::RTrim::create(),
+          string::Trim::create(),
+          string::ToLower::create(),
+          string::ToUpper::create(),
+          string::Reverse::create(),
+          string::Split::create(),
+          string::Substring::create(),
           string::ToString::create(),
           value::HasLabel::create(),
           value::HasLabels::create(),
@@ -264,6 +289,14 @@ macro_rules! make_function_call {
       $crate::functions::make_function_argument!($function_name, arguments_iter, 1, $arg_type_1),
     )
   }};
+  ($function_name: ident, $function: expr, $arguments: ident, $arg_type_0: ty, $arg_type_1: ty, $arg_type_2: ty, ) => {{
+    let mut arguments_iter = $arguments.into_iter();
+    $function(
+      $crate::functions::make_function_argument!($function_name, arguments_iter, 0, $arg_type_0),
+      $crate::functions::make_function_argument!($function_name, arguments_iter, 1, $arg_type_1),
+      $crate::functions::make_function_argument!($function_name, arguments_iter, 2, $arg_type_2),
+    )
+  }};
   ($function_name: ident, $function: expr, $arguments: ident, ) => {
     $function()
   };
@@ -308,34 +341,43 @@ macro_rules! default_validate_ {
 
 #[rustfmt::skip]
 macro_rules! validate_args_ {
-  ($function_name: ident, $ret_type: ty, $( $expression_type: pat ),* ) => {
+  ($function_name: ident, $min_arg_count: expr, $ret_type: ty, $( $expression_type: pat ),* ) => {
     |args: Vec<$crate::compiler::expression_analyser::ExpressionType>|
       -> crate::Result<$crate::compiler::expression_analyser::ExpressionType>
     {
-      const ARG_COUNT: usize = $crate::functions::count_patterns!($( $expression_type,)*); 
-      if args.len() != ARG_COUNT
+      const MAX_ARG_COUNT: usize = $crate::functions::count_patterns!($( $expression_type,)*); 
+      if args.len() > MAX_ARG_COUNT && args.len() < $min_arg_count
       {
         Err(crate::error::CompileTimeError::InvalidNumberOfArguments {
           function_name: stringify!($function_name),
           got: args.len(),
-          expected: ARG_COUNT
+          expected: $min_arg_count
         })?;
       }
       let mut it = args.into_iter();
       $(
-        match it.next().unwrap()
+        if let Some(val) = it.next()
         {
-          $expression_type | ExpressionType::Variant => 
-          Ok(<$ret_type>::result_type()),
-          _ => Err(crate::error::CompileTimeError::InvalidArgumentType.into())
+          match val
+          {
+            $expression_type | ExpressionType::Variant => {}
+            _ => return Err(crate::error::CompileTimeError::InvalidArgumentType.into())
+          }
         }
       )*
+      Ok(<$ret_type>::result_type())
+    }
+  };
+  ($function_name: ident, $ret_type: ty, $( $expression_type: pat ),* ) => {
+    {
+      const MIN_ARG_COUNT: usize = $crate::functions::count_patterns!($( $expression_type,)*);
+      $crate::functions::validate_args_!($function_name, MIN_ARG_COUNT, $ret_type, $( $expression_type ),* )
     }
   };
 }
 
 macro_rules! declare_function_ {
-  ($function_name: ident, $type_name: ty, $f_name: ident (  $( $arg_type: ty $(,)? )* ) -> $ret_type: ty, $allow_null: expr, $validator: block ) => {
+  ($function_name: ident, $type_name: ty, $f_name: ident (  $( $arg_type: ty $(,)? )* ) -> $ret_type: ty, $null_handling: block, $validator: block , $default_args: block ) => {
     impl $type_name
     {
       pub(super) fn create() -> (String, crate::functions::Function)
@@ -348,12 +390,13 @@ macro_rules! declare_function_ {
     }
     impl crate::functions::FunctionTrait for $type_name
     {
-      fn call(&self, arguments: Vec<crate::value::Value>) -> crate::Result<crate::value::Value>
+      fn call(&self, mut arguments: Vec<crate::value::Value>) -> crate::Result<crate::value::Value>
       {
         const ARG_COUNT: usize = $crate::functions::count_arguments!($( $arg_type,)*);
+        ($default_args)(&mut arguments);
         if arguments.len() == ARG_COUNT
         {
-          if !$allow_null && ARG_COUNT > 0 && arguments.iter().all(|x| x.is_null())
+          if $null_handling(&arguments)
           {
             return Ok(crate::value::Value::Null)
           }
@@ -385,21 +428,102 @@ macro_rules! declare_function_ {
   };
 }
 
+macro_rules! no_null_handling_ {
+  () => {
+    |_args: &Vec<graphcore::Value>| false
+  };
+}
+
+macro_rules! null_handling_once_ {
+  (null_returns_null, $iter: expr) => {
+    if $iter.next().map_or(true, |x| x.is_null())
+    {
+      return true;
+    }
+  };
+  (ignore, $iter: expr) => {
+    let _ = $iter.next();
+  };
+}
+
+macro_rules! null_handling_ {
+  ( $( $null_mode: ident ),+ ) => {
+    |args: &Vec<graphcore::Value>| -> bool {
+      let mut iter = args.iter();
+      $( crate::functions::null_handling_once_!($null_mode, iter); )+
+      false
+    }
+  }
+}
+
+macro_rules! no_default_args_ {
+  () => {
+    |_args: &mut Vec<graphcore::Value>| {}
+  };
+}
+
+macro_rules! default_args_ {
+  ( $required: expr, $( $default_arg: expr ),+ ) => {
+    |args: &mut Vec<graphcore::Value>| {
+      if args.len() < $required
+      {
+        return;
+      }
+      let mut current_idx = $required;
+      $(
+        if current_idx >= args.len()
+        {
+          args.push(($default_arg).into());
+        }
+        #[allow(unused_assignments)]
+        {
+          current_idx += 1;
+        }
+      )+
+    }
+  }
+}
+
 macro_rules! declare_function {
   ($function_name: ident, $type_name: ty, $f_name: ident (  $( $arg_type: ty $(,)? )* ) -> $ret_type: ty ) => {
     $crate::functions::declare_function_!($function_name, $type_name,
-      $f_name (  $( $arg_type, )* ) -> $ret_type, false,
-      {$crate::functions::default_validate_!($function_name, $ret_type)} );
+      $f_name (  $( $arg_type, )* ) -> $ret_type,
+      {$crate::functions::no_null_handling_!()},
+      {$crate::functions::default_validate_!($function_name, $ret_type)},
+      {$crate::functions::no_default_args_!()}
+    );
   };
-  ($function_name: ident, $type_name: ty, $f_name: ident (  $( $arg_type: ty $(,)? )* ) -> $ret_type: ty, accept_null ) => {
+  ($function_name: ident, $type_name: ty, $f_name: ident (  $( $arg_type: ty $(,)? )* ) -> $ret_type: ty, null_handling( $( $null_mode: ident ),+ ) ) => {
     $crate::functions::declare_function_!($function_name, $type_name,
-      $f_name (  $( $arg_type, )* ) -> $ret_type, true,
-      {$crate::functions::default_validate_!($function_name, $ret_type)} );
+      $f_name (  $( $arg_type, )* ) -> $ret_type,
+      {$crate::functions::null_handling_!($($null_mode),+)},
+      {$crate::functions::default_validate_!($function_name, $ret_type)},
+      {$crate::functions::no_default_args_!()}
+    );
   };
   ($function_name: ident, $type_name: ty, $f_name: ident (  $( $arg_type: ty $(,)? )* ) -> $ret_type: ty, validate_args( $( $expression_types: pat ),+ ) ) => {
     $crate::functions::declare_function_!($function_name, $type_name,
-      $f_name (  $( $arg_type, )* ) -> $ret_type, false,
-      {$crate::functions::validate_args_!($function_name, $ret_type, $( $expression_types ),+ )} );
+      $f_name (  $( $arg_type, )* ) -> $ret_type,
+      {$crate::functions::no_null_handling_!()},
+      {$crate::functions::validate_args_!($function_name, $ret_type, $( $expression_types ),+ )},
+      {$crate::functions::no_default_args_!()}
+    );
+  };
+  ($function_name: ident, $type_name: ty, $f_name: ident (  $( $arg_type: ty $(,)? )* ) -> $ret_type: ty, null_handling( $( $null_mode: ident ),+ ), validate_args( $( $expression_types: pat ),+ ) ) => {
+    $crate::functions::declare_function_!($function_name, $type_name,
+      $f_name (  $( $arg_type, )* ) -> $ret_type,
+      {$crate::functions::null_handling_!($($null_mode),+)},
+      {$crate::functions::validate_args_!($function_name, $ret_type, $( $expression_types ),+ )},
+      {$crate::functions::no_default_args_!()}
+    );
+  };
+  ($function_name: ident, $type_name: ty, $f_name: ident (  $( $arg_type: ty $(,)? )* ) -> $ret_type: ty, null_handling( $( $null_mode: ident ),+ ), validate_args( $( $expression_types: pat ),+ ), default_args( $required: expr, $( $default_args: expr ),+ ) ) => {
+    $crate::functions::declare_function_!($function_name, $type_name,
+      $f_name (  $( $arg_type, )* ) -> $ret_type,
+      {$crate::functions::null_handling_!($($null_mode),+)},
+      {$crate::functions::validate_args_!($function_name, $required, $ret_type, $( $expression_types ),+ )},
+      {$crate::functions::default_args_!( $required, $($default_args),+)}
+    );
   };
   ($function_name: ident, $type_name: ty, custom_trait ) => {
     impl $type_name
@@ -415,11 +539,8 @@ macro_rules! declare_function {
   };
 }
 
-pub(crate) use count_arguments;
-pub(crate) use count_patterns;
-pub(crate) use declare_function;
-pub(crate) use declare_function_;
-pub(crate) use default_validate_;
-pub(crate) use make_function_argument;
-pub(crate) use make_function_call;
-pub(crate) use validate_args_;
+pub(crate) use {
+  count_arguments, count_patterns, declare_function, declare_function_, default_args_,
+  default_validate_, make_function_argument, make_function_call, no_default_args_,
+  no_null_handling_, null_handling_, null_handling_once_, validate_args_,
+};

data/ext/gqlitedb/src/parser/gql.pest

@@ -1,4 +1,4 @@
-WHITESPACE     = _{ " " | "\t" | "\n" }
+WHITESPACE     = _{ " " | "\t" | "\n" | "\r\n" }
 COMMENT        = _{ ("//" ~ (!"\n" ~ ANY)*) | ("/*" ~ (!"*/" ~ ANY)* ~ "*/") }
 ident          = @{ ASCII_ALPHA ~ (ASCII_ALPHANUMERIC | "_")* }
 parameter_name = @{ (ASCII_ALPHANUMERIC | "_")* }

data/ext/gqlitedb/src/store/postgres.rs

@@ -5,15 +5,15 @@ use ccutils::pool::{self, Pool};
 use crate::{
   prelude::*,
   store::{
-    sqlbase::{SqlBindingValue, SqlResultValue},
     TransactionBoxable,
+    sqlbase::{SqlBindingValue, SqlResultValue},
   },
 };
 
 ccutils::assert_impl_all!(Store: Sync, Send);
 
 use askama::Template;
-use postgres::{types::ToSql, NoTls};
+use postgres::{NoTls, types::ToSql};
 
 const SCHEMA: &str = "public";
 
@@ -126,14 +126,12 @@ impl Drop for TransactionBase
   fn drop(&mut self)
   {
     if *self.active.borrow()
+      && let Err(e) = self.client.query("ROLLBACK", &[])
     {
-      if let Err(e) = self.client.query("ROLLBACK", &[])
-      {
-        println!(
-          "Rollback failed with error {:?}, future use of the connection are likely to fail.",
-          e
-        );
-      }
+      println!(
+        "Rollback failed with error {:?}, future use of the connection are likely to fail.",
+        e
+      );
     }
   }
 }
@@ -336,7 +334,7 @@ impl Store
     Ok(s)
   }
   fn upgrade_database(&self, _transaction: &mut TransactionBox, _from: utils::Version)
-    -> Result<()>
+  -> Result<()>
   {
     // No release with postgres, so nothing to upgrade
     Ok(())
@@ -559,7 +557,7 @@ impl super::sqlbase::SqlQueries for Store
   }
 
   fn node_delete_query(graph_name: impl AsRef<str>, keys: impl AsRef<Vec<String>>)
-    -> Result<String>
+  -> Result<String>
   {
     Ok(
       templates::NodeDelete {
@@ -608,7 +606,7 @@ impl super::sqlbase::SqlQueries for Store
     )
   }
   fn edge_delete_query(graph_name: impl AsRef<str>, keys: impl AsRef<Vec<String>>)
-    -> Result<String>
+  -> Result<String>
   {
     Ok(
       templates::EdgeDelete {

data/ext/gqlitedb/src/store/sqlite.rs

@@ -5,8 +5,8 @@ use ccutils::pool::{self, Pool};
 use crate::{
   prelude::*,
   store::{
-    sqlbase::{SqlBindingValue, SqlResultValue},
     TransactionBoxable,
+    sqlbase::{SqlBindingValue, SqlResultValue},
   },
   utils::hex,
 };
@@ -84,14 +84,12 @@ impl Drop for TransactionBase
   fn drop(&mut self)
   {
     if *self.active.borrow()
+      && let Err(e) = self.connection.execute("ROLLBACK", ())
     {
-      if let Err(e) = self.connection.execute("ROLLBACK", ())
-      {
-        println!(
-          "Rollback failed with error {:?}, future use of the connection are likely to fail.",
-          e
-        );
-      }
+      println!(
+        "Rollback failed with error {:?}, future use of the connection are likely to fail.",
+        e
+      );
     }
   }
 }
@@ -578,7 +576,7 @@ impl super::sqlbase::SqlQueries for Store
   }
 
   fn node_delete_query(graph_name: impl AsRef<str>, keys: impl AsRef<Vec<String>>)
-    -> Result<String>
+  -> Result<String>
   {
     Ok(
       templates::NodeDelete {
@@ -627,7 +625,7 @@ impl super::sqlbase::SqlQueries for Store
     )
   }
   fn edge_delete_query(graph_name: impl AsRef<str>, keys: impl AsRef<Vec<String>>)
-    -> Result<String>
+  -> Result<String>
   {
     Ok(
       templates::EdgeDelete {

data/ext/gqlitedb/src/store.rs

@@ -286,27 +286,21 @@ impl SelectNodeQuery
       return true;
     }
     if let Some(keys) = &self.keys
+      && !keys.iter().any(|x| node.key() == *x)
     {
-      if !keys.iter().any(|x| node.key() == *x)
-      {
-        return false;
-      }
+      return false;
     }
     if let Some(labels) = &self.labels
+      && !labels.iter().all(|x| node.labels().contains(x))
     {
-      if !labels.iter().all(|x| node.labels().contains(x))
-      {
-        return false;
-      }
+      return false;
     }
     if let Some(properties) = &self.properties
-    {
-      if !properties
+      && !properties
         .iter()
         .all(|(k, v)| node.properties().get(k) == Some(v))
-      {
-        return false;
-      }
+    {
+      return false;
     }
     true
   }
@@ -414,28 +408,25 @@ impl SelectEdgeQuery
   pub(crate) fn is_match(&self, edge: &graph::Path) -> bool
   {
     if let Some(keys) = &self.keys
+      && !keys.iter().any(|x| edge.key() == *x)
     {
-      if !keys.iter().any(|x| edge.key() == *x)
-      {
-        return false;
-      }
+      return false;
     }
+
     if let Some(labels) = &self.labels
+      && !labels.iter().all(|x| edge.labels().contains(x))
     {
-      if !labels.iter().all(|x| edge.labels().contains(x))
-      {
-        return false;
-      }
+      return false;
     }
+
     if let Some(properties) = &self.properties
-    {
-      if !properties
+      && !properties
         .iter()
         .all(|(k, v)| edge.properties().get(k) == Some(v))
-      {
-        return false;
-      }
+    {
+      return false;
     }
+
     self.source.is_match(edge.source()) && self.destination.is_match(edge.destination())
   }
 }

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: gqlite
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.5.1
 platform: ruby
 authors:
 - Cyrille Berger
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-18 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -56,7 +55,6 @@ description: "GQLite is a Rust-language library, with a C interface, that implem
   => ex\n  # Report any error\n  puts \"An error has occured: #{ex.message}\"\nend\n\n```\n\nThe
   documentation for the GQL query language can found in [OpenCypher](https://auksys.org/documentation/5/libraries/gqlite/opencypher/)
   and for the [API](https://auksys.org/documentation/5/libraries/gqlite/api/).\n\n"
-email:
 executables: []
 extensions:
 - ext/gqliterb/extconf.rb
@@ -83,6 +81,7 @@ files:
 - ext/gqlitedb/src/consts.rs
 - ext/gqlitedb/src/error.rs
 - ext/gqlitedb/src/functions.rs
+- ext/gqlitedb/src/functions/common.rs
 - ext/gqlitedb/src/functions/containers.rs
 - ext/gqlitedb/src/functions/edge.rs
 - ext/gqlitedb/src/functions/math.rs
@@ -186,7 +185,6 @@ homepage: https://gitlab.com/auksys/gqlite
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -201,8 +199,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.20
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Ruby bindings for GQLite, a Graph Query library.
 test_files: []