gqlite 1.1.0 → 1.2.2

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

@@ -0,0 +1,115 @@
+use super::{ExpressionType, FResult, FunctionTypeTrait};
+use crate::prelude::*;
+
+#[derive(Debug, Default)]
+pub(super) struct Head {}
+
+impl Head
+{
+  fn call_impl(array: &Vec<value::Value>) -> FResult<value::Value>
+  {
+    Ok(
+      array
+        .first()
+        .map(|x| x.to_owned())
+        .unwrap_or(value::Value::Null),
+    )
+  }
+}
+
+super::declare_function!(
+  head,
+  Head,
+  call_impl(Vec<crate::value::Value>) -> crate::value::Value,
+  accept_null
+);
+
+#[derive(Debug, Default)]
+pub(super) struct Keys {}
+
+impl Keys
+{
+  fn call_impl(container: &value::Value) -> Result<Vec<value::Value>>
+  {
+    match container
+    {
+      value::Value::Map(obj) => Ok(obj.keys().map(|x| x.to_owned().into()).collect()),
+      value::Value::Node(n) => Ok(n.properties.keys().map(|x| x.to_owned().into()).collect()),
+      value::Value::Edge(e) => Ok(e.properties.keys().map(|x| x.to_owned().into()).collect()),
+      _ =>
+      {
+        return Err(
+          RunTimeError::InvalidArgument {
+            function_name: "keys",
+            index: 0,
+            expected_type: "map, node or relationship",
+            value: format!("{:?}", container),
+          }
+          .into(),
+        )
+      }
+    }
+  }
+}
+
+super::declare_function!(keys, Keys, call_impl(crate::value::Value) -> Vec<crate::value::Value>, validate_args(ExpressionType::Map | ExpressionType::Node | ExpressionType::Edge | ExpressionType::Null));
+
+#[derive(Debug, Default)]
+pub(super) struct Range {}
+
+impl Range
+{
+  fn call_impl(min: &i64, max: &i64) -> FResult<Vec<i64>>
+  {
+    Ok((*min..=*max).step_by(1).collect())
+  }
+}
+
+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_else(|| 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()),
+      _ =>
+      {
+        return 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/gqliterb/vendor/gqlitedb/src/functions/edge.rs

@@ -0,0 +1,20 @@
+use crate::prelude::*;
+
+use super::{FResult, FunctionTypeTrait};
+
+#[derive(Debug, Default)]
+pub(super) struct Type {}
+
+impl Type
+{
+  fn call_impl(edge: &graph::Edge) -> FResult<String>
+  {
+    edge
+      .labels
+      .first()
+      .ok_or_else(|| RunTimeError::MissingEdgeLabel)
+      .map(|v| v.to_owned())
+  }
+}
+
+super::declare_function!(type, Type, call_impl(crate::graph::Edge) -> String);

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

@@ -0,0 +1,44 @@
+use rand::Rng;
+
+use crate::prelude::*;
+
+use super::{FResult, FunctionTypeTrait};
+
+#[derive(Debug, Default)]
+pub(super) struct Rand {}
+
+impl Rand
+{
+  fn call_impl() -> FResult<f64>
+  {
+    Ok(rand::rng().random())
+  }
+}
+
+super::declare_function!(rand, Rand, call_impl() -> Vec<f64>);
+
+#[derive(Debug, Default)]
+pub(super) struct Ceil {}
+
+impl Ceil
+{
+  fn call_impl(value: &f64) -> FResult<f64>
+  {
+    Ok(value.ceil() as f64)
+  }
+}
+
+super::declare_function!(ceil, Ceil, call_impl(f64) -> f64);
+
+#[derive(Debug, Default)]
+pub(super) struct Floor {}
+
+impl Floor
+{
+  fn call_impl(value: &f64) -> FResult<f64>
+  {
+    Ok(value.floor() as f64)
+  }
+}
+
+super::declare_function!(floor, Floor, call_impl(f64) -> f64);

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

@@ -0,0 +1,16 @@
+use crate::prelude::*;
+
+use super::{FResult, FunctionTypeTrait};
+
+#[derive(Debug, Default)]
+pub(super) struct Labels {}
+
+impl Labels
+{
+  fn call_impl(node: &graph::Node) -> FResult<Vec<String>>
+  {
+    Ok(node.labels.to_owned())
+  }
+}
+
+super::declare_function!(labels, Labels, call_impl(crate::graph::Node) -> Vec<String>);

data/ext/gqliterb/vendor/gqlitedb/src/functions/path.rs

@@ -0,0 +1,48 @@
+use super::ExpressionType;
+use crate::prelude::*;
+
+#[derive(Debug, Default)]
+pub(super) struct Length {}
+
+impl super::FunctionTrait for Length
+{
+  fn call(&self, arguments: Vec<value::Value>) -> crate::Result<value::Value>
+  {
+    let container = arguments
+      .first()
+      .ok_or_else(|| RunTimeError::InvalidNumberOfArguments {
+        function_name: "length",
+        got: arguments.len(),
+        expected: 1,
+      })?;
+
+    match container
+    {
+      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()),
+      _ =>
+      {
+        return Err(
+          RunTimeError::InvalidArgument {
+            function_name: "length",
+            index: 0,
+            expected_type: "array or map",
+            value: format!("{:?}", container),
+          }
+          .into(),
+        )
+      }
+    }
+  }
+  fn validate_arguments(&self, _: Vec<ExpressionType>) -> crate::Result<ExpressionType>
+  {
+    Ok(ExpressionType::Variant)
+  }
+  fn is_deterministic(&self) -> bool
+  {
+    true
+  }
+}
+
+super::declare_function!(length, Length, custom_trait);

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

@@ -0,0 +1,86 @@
+use crate::prelude::*;
+
+use super::{ExpressionType, FResult, FunctionTypeTrait};
+
+#[derive(Debug, Default)]
+pub(super) struct Coalesce {}
+
+impl super::FunctionTrait for Coalesce
+{
+  fn call(&self, arguments: Vec<value::Value>) -> crate::Result<value::Value>
+  {
+    for arg in arguments
+    {
+      match arg
+      {
+        value::Value::Null =>
+        {}
+        other => return Ok(other),
+      }
+    }
+    Ok(value::Value::Null)
+  }
+  fn validate_arguments(&self, _: Vec<ExpressionType>) -> crate::Result<ExpressionType>
+  {
+    Ok(ExpressionType::Variant)
+  }
+  fn is_deterministic(&self) -> bool
+  {
+    true
+  }
+}
+
+super::declare_function!(coalesce, Coalesce, custom_trait);
+
+#[derive(Debug, Default)]
+pub(super) struct ToInteger {}
+
+impl ToInteger
+{
+  fn call_impl(value: &value::Value) -> FResult<i64>
+  {
+    match value
+    {
+      value::Value::Integer(i) => Ok(*i),
+      value::Value::Float(f) => Ok(*f as i64),
+      value::Value::String(s) => Ok(s.parse().map_err(|_| RunTimeError::InvalidArgument {
+        function_name: "toInteger",
+        index: 0,
+        expected_type: "A string convertible to integer",
+        value: format!("{:?}", value),
+      })?),
+      _ => Err(RunTimeError::InvalidArgument {
+        function_name: "toInteger",
+        index: 0,
+        expected_type: "integer, float, or string",
+        value: format!("{:?}", value),
+      }),
+    }
+  }
+}
+
+super::declare_function!(toInteger, ToInteger, call_impl(crate::value::Value) -> i64);
+
+#[derive(Debug, Default)]
+pub(super) struct Properties {}
+
+impl Properties
+{
+  fn call_impl(value: &value::Value) -> FResult<value::ValueMap>
+  {
+    match value
+    {
+      value::Value::Node(n) => Ok(n.properties.to_owned()),
+      value::Value::Edge(e) => Ok(e.properties.to_owned()),
+      value::Value::Map(m) => Ok(m.to_owned()),
+      _ => Err(RunTimeError::InvalidArgument {
+        function_name: "properties",
+        index: 0,
+        expected_type: "node or relationship",
+        value: format!("{:?}", value),
+      }),
+    }
+  }
+}
+
+super::declare_function!(properties, Properties, call_impl(crate::value::Value) -> value::ValueMap, validate_args(ExpressionType::Map | ExpressionType::Node | ExpressionType::Edge | ExpressionType::Null));

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

@@ -0,0 +1,28 @@
+use crate::prelude::*;
+
+use super::{ExpressionType, FResult, FunctionTypeTrait};
+
+#[derive(Debug, Default)]
+pub(super) struct ToString {}
+
+impl ToString
+{
+  fn call_impl(value: &value::Value) -> FResult<String>
+  {
+    match value
+    {
+      value::Value::Boolean(b) => Ok(if *b { "true" } else { "false" }.into()),
+      value::Value::Integer(i) => Ok(i.to_string()),
+      value::Value::Float(f) => Ok(f.to_string()),
+      value::Value::String(s) => Ok(s.to_owned()),
+      _ => Err(RunTimeError::InvalidArgument {
+        function_name: "toString",
+        index: 0,
+        expected_type: "boolean or integer or double",
+        value: format!("{:?}", value),
+      }),
+    }
+  }
+}
+
+super::declare_function!(toString, ToString, call_impl(crate::value::Value) -> String, validate_args(ExpressionType::Boolean | ExpressionType::Integer | ExpressionType::Float | ExpressionType::String | ExpressionType::Null));

data/ext/gqliterb/vendor/gqlitedb/src/functions/value.rs

@@ -0,0 +1,99 @@
+use crate::prelude::*;
+
+use super::{ExpressionType, FResult, FunctionTypeTrait};
+
+#[derive(Debug, Default)]
+pub(super) struct HasLabel {}
+
+impl HasLabel
+{
+  fn call_impl(value: &value::Value, label: &String) -> FResult<bool>
+  {
+    match value
+    {
+      value::Value::Edge(e) => Ok(e.labels.contains(label)),
+      value::Value::Node(n) => Ok(n.labels.contains(label)),
+      _ => Err(RunTimeError::InvalidArgument {
+        function_name: "has_label",
+        index: 0,
+        expected_type: "node or edege",
+        value: format!("{:?}", value),
+      }),
+    }
+  }
+}
+
+super::declare_function!(has_label, HasLabel, call_impl(crate::graph::Edge, String) -> bool);
+
+#[derive(Debug, Default)]
+pub(super) struct HasLabels {}
+
+impl super::FunctionTrait for HasLabels
+{
+  fn call(&self, arguments: Vec<value::Value>) -> crate::Result<value::Value>
+  {
+    if arguments.len() < 2
+    {
+      Err(
+        RunTimeError::InvalidNumberOfArguments {
+          function_name: "has_labels",
+          got: arguments.len(),
+          expected: 2,
+        }
+        .into(),
+      )
+    }
+    else
+    {
+      let mut it = arguments.into_iter();
+      let labels = match it.next().unwrap()
+      {
+        value::Value::Edge(e) => e.labels,
+        value::Value::Node(n) => n.labels,
+        value::Value::Null => return Ok(value::Value::Null),
+        _ => Err(RunTimeError::InvalidArgument {
+          function_name: "has_labels",
+          index: 0,
+          expected_type: "node or edge",
+          value: format!("{:?}", it),
+        })?,
+      };
+      for (index, label) in it.enumerate()
+      {
+        match label
+        {
+          value::Value::String(l) =>
+          {
+            if !labels.contains(&l)
+            {
+              return Ok(false.into());
+            }
+          }
+          _ =>
+          {
+            return Err(
+              RunTimeError::InvalidArgument {
+                function_name: "has_labels",
+                index,
+                expected_type: "string",
+                value: format!("{:?}", label),
+              }
+              .into(),
+            )
+          }
+        }
+      }
+      Ok(true.into())
+    }
+  }
+  fn validate_arguments(&self, _: Vec<ExpressionType>) -> crate::Result<ExpressionType>
+  {
+    Ok(ExpressionType::Boolean)
+  }
+  fn is_deterministic(&self) -> bool
+  {
+    true
+  }
+}
+
+super::declare_function!(has_labels, HasLabels, custom_trait);