gqlite 1.2.0 → 1.2.2

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

@@ -0,0 +1,212 @@
+use std::cmp;
+
+use itertools::Itertools;
+
+use crate::prelude::*;
+
+pub(crate) enum Ordering
+{
+  Equal,
+  Different,
+  Less,
+  Greater,
+  ComparedNull,
+  Null,
+}
+
+impl From<cmp::Ordering> for Ordering
+{
+  fn from(value: cmp::Ordering) -> Self
+  {
+    match value
+    {
+      cmp::Ordering::Equal => Ordering::Equal,
+      cmp::Ordering::Greater => Ordering::Greater,
+      cmp::Ordering::Less => Ordering::Less,
+    }
+  }
+}
+
+fn compare_map(lhs: &value::ValueMap, rhs: &value::ValueMap) -> Ordering
+{
+  if lhs.len() == rhs.len()
+  {
+    lhs
+      .iter()
+      .sorted_by(|(lk, _), (rk, _)| lk.cmp(rk))
+      .zip(rhs.iter().sorted_by(|(lk, _), (rk, _)| lk.cmp(rk)))
+      .map(|((lhs_k, lhs_v), (rhs_k, rhs_v))| {
+        let cmp = lhs_k.cmp(rhs_k);
+        match cmp
+        {
+          std::cmp::Ordering::Equal => compare(lhs_v, rhs_v),
+          o => o.into(),
+        }
+      })
+      .find(|p| match p
+      {
+        Ordering::Equal => false,
+        _ => true,
+      })
+      .unwrap_or(Ordering::Equal)
+  }
+  else if lhs.len() < rhs.len()
+  {
+    Ordering::Less
+  }
+  else
+  {
+    Ordering::Greater
+  }
+}
+
+fn compare_f64(lhs: &f64, rhs: &f64) -> Ordering
+{
+  if lhs.is_nan() || rhs.is_nan()
+  {
+    Ordering::Different
+  }
+  else
+  {
+    lhs.total_cmp(rhs).into()
+  }
+}
+
+fn compare_node(lhs: &graph::Node, rhs: &graph::Node) -> Ordering
+{
+  lhs.key.uuid.cmp(&rhs.key.uuid).into()
+}
+
+pub(crate) fn compare(lhs: &value::Value, rhs: &value::Value) -> Ordering
+{
+  use value::Value;
+  match lhs
+  {
+    Value::Null => Ordering::ComparedNull,
+    Value::Boolean(bl) => match rhs
+    {
+      Value::Boolean(br) => bl.cmp(br).into(),
+      Value::Null => Ordering::ComparedNull,
+      _ => Ordering::Null,
+    },
+    Value::Integer(il) => match rhs
+    {
+      Value::Integer(ir) => il.cmp(ir).into(),
+      Value::Float(fr) => compare_f64(&(*il as f64), fr),
+      Value::Null => Ordering::ComparedNull,
+      _ => Ordering::Null,
+    },
+    Value::Float(fl) => match rhs
+    {
+      Value::Integer(ir) => compare_f64(fl, &(*ir as f64)),
+      Value::Float(fr) => compare_f64(fl, fr),
+      Value::Null => Ordering::ComparedNull,
+      _ => Ordering::Null,
+    },
+    Value::String(sl) => match rhs
+    {
+      Value::String(sr) => sl.cmp(sr).into(),
+      Value::Null => Ordering::ComparedNull,
+      _ => Ordering::Null,
+    },
+    Value::Array(al) => match rhs
+    {
+      Value::Array(ar) =>
+      {
+        if al.len() < ar.len()
+        {
+          Ordering::Less
+        }
+        else if al.len() > ar.len()
+        {
+          Ordering::Greater
+        }
+        else
+        {
+          let mut comp_to_null = false;
+          let mut compare_equal = true;
+          let comp = al
+            .iter()
+            .zip(ar.iter())
+            .find_map(|(l, r)| match compare(l, r)
+            {
+              Ordering::Equal => None,
+              Ordering::Null | Ordering::Different =>
+              {
+                compare_equal = false;
+                None
+              }
+              Ordering::Greater => Some(Ordering::Greater),
+              Ordering::Less => Some(Ordering::Less),
+              Ordering::ComparedNull =>
+              {
+                comp_to_null = true;
+                None
+              }
+            });
+
+          // Due to opencypher madness, if you compare [nil, 2] with [1, 2] this should return null because of the nil/1 comparison,
+          // however [nil, 2] with [1, "2"] should return false because 2 != "2" 🤦
+          match (comp, comp_to_null, compare_equal)
+          {
+            // Some imply either greater or lesser, in which case, return the value unless a comparison to null was made
+            (Some(o), false, _) => o,
+            (Some(_), true, _) => Ordering::ComparedNull,
+            // If equal, check if a comparison to null was made
+            (None, true, true) => Ordering::ComparedNull,
+            (None, false, true) => Ordering::Equal,
+            // If false, ignore comparison to null
+            (None, _, false) => Ordering::Null,
+          }
+        }
+      }
+      Value::Null => Ordering::ComparedNull,
+      _ => Ordering::Null,
+    },
+    Value::Map(lhs) => match rhs
+    {
+      Value::Map(rhs) => compare_map(lhs, rhs),
+      _ => Ordering::Null,
+    },
+    Value::Node(lhs) => match rhs
+    {
+      Value::Node(rhs) => compare_node(lhs, rhs),
+      _ => Ordering::Null,
+    },
+    Value::Edge(lhs) => match rhs
+    {
+      Value::Edge(rhs) =>
+      {
+        lhs.key.uuid.cmp(&rhs.key.uuid).into()
+        // let labels_cmp = lhs.labels.cmp(&rhs.labels);
+        // match labels_cmp
+        // {
+        //   std::cmp::Ordering::Equal => compare_map(&lhs.properties, &rhs.properties),
+        //   o => o.into(),
+        // }
+      }
+      _ => Ordering::Null,
+    },
+    Value::Path(lhs) => match rhs
+    {
+      Value::Path(rhs) =>
+      {
+        let labels_cmp = lhs.labels.cmp(&rhs.labels);
+        match labels_cmp
+        {
+          std::cmp::Ordering::Equal => match compare_map(&lhs.properties, &rhs.properties)
+          {
+            Ordering::Equal => match compare_node(&lhs.source, &rhs.source)
+            {
+              Ordering::Equal => compare_node(&lhs.destination, &rhs.destination),
+              o => o,
+            },
+            o => o,
+          },
+          o => o.into(),
+        }
+      }
+      _ => Ordering::Null,
+    },
+  }
+}

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

@@ -0,0 +1,47 @@
+use crate::prelude::*;
+
+pub(crate) enum ContainResult
+{
+  True,
+  False,
+  ComparedNull,
+}
+
+/// Compute contains, according to OpenCypher specification, specifically handling the comparison with null.
+pub(crate) fn contains(container: &Vec<value::Value>, value: &value::Value) -> ContainResult
+{
+  if value.is_null()
+  {
+    if container.is_empty()
+    {
+      ContainResult::False
+    }
+    else
+    {
+      ContainResult::ComparedNull
+    }
+  }
+  else
+  {
+    let mut has_compared_to_null = false;
+    for v_c in container.iter()
+    {
+      use value::ContainResult;
+      match value::compare(v_c, &value)
+      {
+        value::Ordering::Equal => return ContainResult::True,
+        value::Ordering::ComparedNull => has_compared_to_null = true,
+        _ =>
+        {}
+      }
+    }
+    if has_compared_to_null
+    {
+      ContainResult::ComparedNull
+    }
+    else
+    {
+      ContainResult::False
+    }
+  }
+}

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

@@ -0,0 +1,298 @@
+use itertools::Itertools;
+use serde::{Deserialize, Serialize};
+use std::{
+  hash::Hash,
+  ops::{Deref, DerefMut},
+};
+
+use crate::{prelude::*, Value};
+
+type ValueMapInner = std::collections::HashMap<String, Value>;
+
+/// A map of values.
+#[derive(Debug, PartialEq, Default, Clone, Deserialize, Serialize)]
+pub struct ValueMap(ValueMapInner);
+
+impl ValueMap
+{
+  /// Create a default value map.
+  pub fn new() -> Self
+  {
+    Self::default()
+  }
+  pub(crate) fn remove_null(self) -> Self
+  {
+    self
+      .into_iter()
+      .filter(|(_, v)| !v.is_null())
+      .map(|(k, v)| (k, v.remove_null()))
+      .collect()
+  }
+  pub(crate) fn remove_value<'a>(
+    &mut self,
+    field: Option<&'a String>,
+    mut path: impl Iterator<Item = &'a String>,
+  ) -> crate::Result<()>
+  {
+    if let Some(field) = field
+    {
+      if let Some(next_field) = path.next()
+      {
+        let v = self.get_mut(field);
+        match v
+        {
+          Some(Value::Map(o)) =>
+          {
+            o.remove_value(Some(next_field), path)?;
+          }
+          None =>
+          {}
+          _ => Err(InternalError::Unimplemented(
+            "remove_value should get a better error",
+          ))?, // TODO
+        }
+      }
+      else
+      {
+        self.remove(field);
+      }
+    }
+    else
+    {
+      Err(InternalError::Unimplemented(
+        "remove_value should get a better error",
+      ))? // TODO
+    }
+    Ok(())
+  }
+  pub(crate) fn add_values<'a>(
+    &mut self,
+    field: Option<&'a String>,
+    mut path: impl Iterator<Item = &'a String>,
+    value: ValueMap,
+  ) -> crate::Result<()>
+  {
+    if let Some(field) = field
+    {
+      let v = self.get_mut(field);
+
+      if let Some(next_field) = path.next()
+      {
+        match v
+        {
+          Some(Value::Map(o)) =>
+          {
+            o.add_values(Some(next_field), path, value)?;
+          }
+          None =>
+          {
+            let mut o = ValueMap::new();
+            o.set_value(Some(next_field), path, value.remove_null().into())?;
+            self.insert(field.to_owned(), o.into());
+          }
+          _ => Err(InternalError::Unimplemented(
+            "add_values should get a better error",
+          ))?, // TODO
+        }
+      }
+      else
+      {
+        match v
+        {
+          Some(v) =>
+          {
+            match v
+            {
+              Value::Map(object) =>
+              {
+                for (k, v) in value.into_iter()
+                {
+                  if v.is_null()
+                  {
+                    object.remove(&k);
+                  }
+                  else
+                  {
+                    object.insert(k, v);
+                  }
+                }
+              }
+              _ => Err(InternalError::Unimplemented(
+                "add_values should get a better error",
+              ))?, // TODO
+            }
+          }
+          None =>
+          {
+            self.insert(field.to_owned(), value.remove_null().into());
+          }
+        }
+      }
+    }
+    else
+    {
+      for (k, v) in value.into_iter()
+      {
+        if v.is_null()
+        {
+          self.remove(&k);
+        }
+        else
+        {
+          self.insert(k, v);
+        }
+      }
+    }
+    Ok(())
+  }
+  pub(crate) fn set_value<'a>(
+    &mut self,
+    field: Option<&'a String>,
+    mut path: impl Iterator<Item = &'a String>,
+    value: Value,
+  ) -> crate::Result<()>
+  {
+    if let Some(field) = field
+    {
+      let v = self.get_mut(field);
+
+      if let Some(next_field) = path.next()
+      {
+        match v
+        {
+          Some(Value::Map(o)) =>
+          {
+            o.set_value(Some(next_field), path, value)?;
+          }
+          None =>
+          {
+            if !value.is_null()
+            {
+              let mut o = ValueMap::new();
+              o.set_value(Some(next_field), path, value)?;
+              self.insert(field.to_owned(), o.into());
+            }
+          }
+          _ => Err(InternalError::Unimplemented(
+            "update_value should get a better error",
+          ))?, // TODO
+        }
+      }
+      else
+      {
+        if value.is_null()
+        {
+          self.remove(field);
+        }
+        else
+        {
+          match v
+          {
+            Some(v) =>
+            {
+              *v = value;
+            }
+            None =>
+            {
+              self.insert(field.to_owned(), value);
+            }
+          }
+        }
+      }
+
+      Ok(())
+    }
+    else
+    {
+      match value
+      {
+        Value::Map(o) =>
+        {
+          *self = o;
+          Ok(())
+        }
+        _ => Err(InternalError::Unimplemented("set_value should get a better error").into()), // TODO
+      }
+    }
+  }
+}
+
+impl Hash for ValueMap
+{
+  fn hash<H: std::hash::Hasher>(&self, state: &mut H)
+  {
+    for (k, v) in self.0.iter().sorted_by(|(lk, _), (rk, _)| lk.cmp(rk))
+    {
+      k.hash(state);
+      v.hash(state);
+    }
+  }
+}
+
+impl Deref for ValueMap
+{
+  type Target = ValueMapInner;
+  fn deref(&self) -> &Self::Target
+  {
+    &self.0
+  }
+}
+
+impl DerefMut for ValueMap
+{
+  fn deref_mut(&mut self) -> &mut Self::Target
+  {
+    &mut self.0
+  }
+}
+
+impl FromIterator<(String, Value)> for ValueMap
+{
+  /// Constructs a `HashMap<K, V>` from an iterator of key-value pairs.
+  ///
+  /// If the iterator produces any pairs with equal keys,
+  /// all but one of the corresponding values will be dropped.
+  fn from_iter<T: IntoIterator<Item = (String, Value)>>(iter: T) -> ValueMap
+  {
+    let mut map = ValueMapInner::with_hasher(Default::default());
+    map.extend(iter);
+    ValueMap(map)
+  }
+}
+
+impl IntoIterator for ValueMap
+{
+  type Item = (String, Value);
+  type IntoIter = <ValueMapInner as IntoIterator>::IntoIter;
+  fn into_iter(self) -> Self::IntoIter
+  {
+    self.0.into_iter()
+  }
+}
+
+impl<const N: usize> From<[(String, Value); N]> for ValueMap
+{
+  fn from(arr: [(String, Value); N]) -> Self
+  {
+    Self(ValueMapInner::from_iter(arr))
+  }
+}
+
+impl std::fmt::Display for ValueMap
+{
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
+  {
+    write!(f, "{{")?;
+    self.iter().enumerate().for_each(|(n, (k, v))| {
+      if n == 0
+      {
+        write!(f, "{}: {}", k, v).unwrap();
+      }
+      else
+      {
+        write!(f, ", {}: {}", k, v).unwrap();
+      }
+    });
+    write!(f, "}}")
+  }
+}