gqlite 1.5.0 → 1.7.0

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

@@ -1,9 +1,42 @@
-use rand::Rng;
+use rand::RngExt;
 
 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 {}
 
@@ -15,30 +48,69 @@ impl Rand
   }
 }
 
-super::declare_function!(rand, Rand, call_impl() -> Vec<f64>);
+super::declare_function!(rand, Rand, call_impl() -> Vec<f64>, non_deterministic);
+
+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);
-
-#[derive(Debug, Default)]
-pub(super) struct Floor {}
+super::declare_function!(atan2, Atan2, call_impl(f64, f64) -> f64);
 
-impl Floor
+#[cfg(test)]
+mod test
 {
-  fn call_impl(value: f64) -> FResult<f64>
+  use crate::functions::math::{Extra as _, Rand};
+  #[test]
+  fn test_cot()
   {
-    Ok(value.floor())
+    assert_eq!(0.5_f64.cot(), 1.830487721712452);
+  }
+  #[test]
+  fn test_rand()
+  {
+    assert!(!Rand::create().1.is_deterministic());
   }
 }
-
-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/path.rs

@@ -20,7 +20,8 @@ impl super::FunctionTrait for Length
     {
       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()),
+      value::Value::SinglePath(_) => Ok((1_i64).into()),
+      value::Value::Path(path) => Ok((path.elements_count() as i64).into()),
       _ => Err(
         RunTimeError::InvalidArgument {
           function_name: "length",
@@ -49,27 +50,63 @@ pub(super) struct Nodes {}
 
 impl Nodes
 {
-  fn call_impl(path: graph::Path) -> FResult<Vec<graph::Node>>
+  fn call_impl(path: value::Value) -> FResult<Vec<graph::Node>>
   {
-    Ok(vec![path.source().clone(), path.destination().clone()])
+    match path
+    {
+      value::Value::SinglePath(p) =>
+      {
+        let (node, _, destination) = p.unpack();
+        Ok(vec![node, destination])
+      }
+      value::Value::Path(p) =>
+      {
+        let (source, elements) = p.unpack();
+        Ok(
+          std::iter::once(source)
+            .chain(elements.into_iter().map(|(_, node)| node))
+            .collect(),
+        )
+      }
+      o => Err(RunTimeError::InvalidArgument {
+        function_name: "nodes",
+        index: 0,
+        expected_type: "path",
+        value: format!("{:?}", o),
+      }),
+    }
   }
 }
 
-super::declare_function!(nodes, Nodes, call_impl(crate::graph::Path) -> Vec<graph::Node>);
+super::declare_function!(nodes, Nodes, call_impl(value::Value) -> Vec<graph::Node>);
 
 #[derive(Debug, Default)]
 pub(super) struct Edges {}
 
 impl Edges
 {
-  fn call_impl(path: graph::Path) -> FResult<Vec<graph::Edge>>
+  fn call_impl(path: value::Value) -> FResult<Vec<graph::Edge>>
   {
-    Ok(vec![graph::Edge::new(
-      path.key(),
-      path.labels().clone(),
-      path.properties().clone(),
-    )])
+    match path
+    {
+      value::Value::SinglePath(p) =>
+      {
+        let (_, edge, _) = p.unpack();
+        Ok(vec![edge])
+      }
+      value::Value::Path(p) =>
+      {
+        let (_, elements) = p.unpack();
+        Ok(elements.into_iter().map(|(edge, _)| edge).collect())
+      }
+      o => Err(RunTimeError::InvalidArgument {
+        function_name: "edges",
+        index: 0,
+        expected_type: "path",
+        value: format!("{:?}", o),
+      }),
+    }
   }
 }
 
-super::declare_function!(edges, Edges, call_impl(crate::graph::Path) -> Vec<graph::Edge>);
+super::declare_function!(edges, Edges, call_impl(value::Value) -> Vec<graph::Edge>);

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/value.rs

@@ -79,7 +79,7 @@ impl super::FunctionTrait for HasLabels
                 value: format!("{:?}", label),
               }
               .into(),
-            )
+            );
           }
         }
       }