gqlite 1.5.0 → 1.7.0

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(),
@@ -194,6 +219,8 @@ impl Manager
         .clone(),
     )
   }
+  // It has future use in the compiler to optimize constant expressions
+  #[allow(dead_code)]
   pub(crate) fn is_deterministic(&self, name: impl Into<String>) -> Result<bool>
   {
     let name = name.into();
@@ -264,6 +291,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 +343,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, $deterministic: expr ) => {
     impl $type_name
     {
       pub(super) fn create() -> (String, crate::functions::Function)
@@ -348,12 +392,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)
           }
@@ -379,27 +424,122 @@ macro_rules! declare_function_ {
       }
       fn is_deterministic(&self) -> bool
       {
-        true
+        $deterministic
       }
     }
   };
 }
 
+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_!()},
+      true
+    );
   };
-  ($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, non_deterministic ) => {
     $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::no_null_handling_!()},
+      {$crate::functions::default_validate_!($function_name, $ret_type)},
+      {$crate::functions::no_default_args_!()},
+      false
+    );
+  };
+  ($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,
+      {$crate::functions::null_handling_!($($null_mode),+)},
+      {$crate::functions::default_validate_!($function_name, $ret_type)},
+      {$crate::functions::no_default_args_!()},
+      true
+    );
   };
   ($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_!()},
+      true
+    );
+  };
+  ($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_!()},
+      true
+    );
+  };
+  ($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),+)},
+      true
+    );
   };
   ($function_name: ident, $type_name: ty, custom_trait ) => {
     impl $type_name
@@ -415,11 +555,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/graph.rs

@@ -1,11 +1,3 @@
-pub(crate) use graphcore::SinglePath;
-pub use graphcore::{Edge, Key, Node, SinglePath as Path};
+pub use graphcore::{Edge, Key, Node, Path, SinglePath};
 
 pub use graphcore::labels;
-
-#[derive(Debug, Clone, Copy)]
-pub(crate) enum EdgeDirectivity
-{
-  Undirected,
-  Directed,
-}