gqlite 1.5.1 → 1.7.0

data/ext/graphcore/src/value/value_map.rs

@@ -5,7 +5,7 @@ use std::{
   ops::{Deref, DerefMut},
 };
 
-use crate::{prelude::*, Value};
+use crate::{Value, prelude::*};
 
 type ValueMapInner = std::collections::HashMap<String, Value>;
 

data/ext/graphcore/src/value.rs

@@ -5,11 +5,13 @@ use std::{
   ops::{Add, Div, Mul, Neg, Rem, Sub},
 };
 
+mod tensor;
 mod value_map;
 
-pub(crate) use crate::prelude::*;
 use crate::TimeStamp;
+pub(crate) use crate::prelude::*;
 
+pub use tensor::{DType, Tensor};
 pub use value_map::ValueMap;
 
 /// Represent a value in a properties for a Node or an Edge.
@@ -38,14 +40,18 @@ pub enum Value
   TimeStamp(timestamp::TimeStamp),
   /// Array of values.
   Array(Vec<Value>),
+  /// Dense tensor embedding (1D array of floats)
+  Tensor(Tensor),
   /// Unordered map of values.
   Map(ValueMap),
   /// A node in the graph.
   Node(graph::Node),
   /// An edge in the graph.
   Edge(graph::Edge),
+  /// A single path in the graph.
+  SinglePath(Box<graph::SinglePath>),
   /// A path in the graph.
-  Path(graph::SinglePath),
+  Path(Box<graph::Path>),
 }
 
 impl Value
@@ -75,6 +81,42 @@ impl Value
       o => o,
     }
   }
+
+  /// Optimize a value that has been deserialized from a storage layer.
+  /// In particular, convert numeric arrays into native Tensor values.
+  pub fn optimize(self) -> Self
+  {
+    match self
+    {
+      Value::Array(arr) =>
+      {
+        let mut out = Vec::with_capacity(arr.len());
+        let mut all_numeric = true;
+        for v in arr.iter()
+        {
+          match v
+          {
+            Value::Float(f) => out.push(*f as f32),
+            Value::Integer(i) => out.push(*i as f32),
+            _ =>
+            {
+              all_numeric = false;
+              break;
+            }
+          }
+        }
+        if all_numeric
+        {
+          Value::Tensor(Tensor::from_f32_slice(&out))
+        }
+        else
+        {
+          Value::Array(arr.into_iter().map(|v| v.optimize()).collect())
+        }
+      }
+      other => other,
+    }
+  }
 }
 impl Hash for Value
 {
@@ -102,9 +144,25 @@ impl Hash for Value
       Value::String(s) => s.hash(state),
       Value::TimeStamp(ts) => ts.hash(state),
       Value::Array(a) => a.hash(state),
+      Value::Tensor(t) =>
+      {
+        for fl in t.iter()
+        {
+          let bits = if fl.is_nan()
+          {
+            0x7fc00000u32
+          }
+          else
+          {
+            fl.to_bits()
+          };
+          bits.hash(state);
+        }
+      }
       Value::Map(m) => m.hash(state),
       Value::Node(n) => n.hash(state),
       Value::Edge(e) => e.hash(state),
+      Value::SinglePath(p) => p.hash(state),
       Value::Path(p) => p.hash(state),
     }
   }
@@ -123,8 +181,68 @@ impl Add for Value
       | Value::Edge(..)
       | Value::Map(..)
       | Value::TimeStamp(..)
+      | Value::SinglePath(..)
       | Value::Path(..) => Err(Error::InvalidBinaryOperands),
       Value::Null => Ok(Value::Null),
+      Self::Tensor(lhs) => match rhs
+      {
+        Self::Tensor(rhs_v) =>
+        {
+          if lhs.len() != rhs_v.len()
+          {
+            Err(Error::InvalidBinaryOperands)
+          }
+          else
+          {
+            let res = lhs
+              .iter()
+              .zip(rhs_v.iter())
+              .map(|(a, b)| a + b)
+              .collect::<Vec<f32>>();
+            Ok(Value::Tensor(Tensor::from_f32_slice(&res)))
+          }
+        }
+        Self::Float(rhs_f) =>
+        {
+          let scalar = rhs_f as f32;
+          let res = lhs.iter().map(|a| a + scalar).collect::<Vec<f32>>();
+          Ok(Value::Tensor(Tensor::from_f32_slice(&res)))
+        }
+        Self::Integer(rhs_i) =>
+        {
+          let scalar = rhs_i as f32;
+          let res = lhs.iter().map(|a| a + scalar).collect::<Vec<f32>>();
+          Ok(Value::Tensor(Tensor::from_f32_slice(&res)))
+        }
+        Self::Array(arr) =>
+        {
+          let mut rhs_vec = Vec::with_capacity(arr.len());
+          for v in arr.iter()
+          {
+            match v
+            {
+              Value::Float(f) => rhs_vec.push(*f as f32),
+              Value::Integer(i) => rhs_vec.push(*i as f32),
+              _ => return Err(Error::InvalidBinaryOperands),
+            }
+          }
+          if rhs_vec.len() != lhs.len()
+          {
+            Err(Error::InvalidBinaryOperands)
+          }
+          else
+          {
+            let res = lhs
+              .iter()
+              .zip(rhs_vec.iter())
+              .map(|(a, b)| a + b)
+              .collect::<Vec<f32>>();
+            Ok(Value::Tensor(Tensor::from_f32_slice(&res)))
+          }
+        }
+        Self::Null => Ok(Self::Null),
+        _ => Err(Error::InvalidBinaryOperands),
+      },
       Self::Array(lhs) => match rhs
       {
         Self::Array(rhs) =>
@@ -144,6 +262,12 @@ impl Add for Value
       {
         Self::Float(rhs) => Ok((lhs + rhs).into()),
         Self::Integer(rhs) => Ok((lhs + rhs as f64).into()),
+        Self::Tensor(rhs_v) =>
+        {
+          let scalar = lhs as f32;
+          let res = rhs_v.iter().map(|v| scalar + *v).collect::<Vec<f32>>();
+          Ok(Value::Tensor(Tensor::from_f32_slice(&res)))
+        }
         Self::Null => Ok(Self::Null),
         _ => Err(Error::InvalidBinaryOperands),
       },
@@ -151,6 +275,12 @@ impl Add for Value
       {
         Self::Float(rhs) => Ok((lhs as f64 + rhs).into()),
         Self::Integer(rhs) => Ok((lhs + rhs).into()),
+        Self::Tensor(rhs_v) =>
+        {
+          let scalar = lhs as f32;
+          let res = rhs_v.iter().map(|v| scalar + *v).collect::<Vec<f32>>();
+          Ok(Value::Tensor(Tensor::from_f32_slice(&res)))
+        }
         Self::Null => Ok(Self::Null),
         _ => Err(Error::InvalidBinaryOperands),
       },
@@ -181,19 +311,72 @@ macro_rules! impl_mdsr {
           | Value::Edge(..)
           | Value::Array(..)
           | Value::Map(..)
+          | Value::SinglePath(..)
           | Value::Path(..) => Err(Error::InvalidBinaryOperands.into()),
           Value::Null => Ok(Value::Null),
           Self::Float(lhs) => match rhs
           {
             Self::Float(rhs) => Ok(lhs.$op(rhs).into()),
             Self::Integer(rhs) => Ok(lhs.$op(rhs as f64).into()),
+            Self::Tensor(rhs_v) =>
+            {
+              let scalar = lhs as f32;
+              let res = rhs_v.iter().map(|v| scalar.$op(*v)).collect::<Vec<f32>>();
+              Ok(Value::Tensor(Tensor::from_f32_slice(&res)))
+            }
             Self::Null => Ok(Self::Null),
             _ => Err(Error::InvalidBinaryOperands.into()),
           },
+
           Self::Integer(lhs) => match rhs
           {
             Self::Float(rhs) => Ok((lhs as f64).$op(rhs).into()),
             Self::Integer(rhs) => Ok(lhs.$op(rhs).into()),
+            Self::Tensor(rhs_v) =>
+            {
+              let scalar = lhs as f32;
+              let res = rhs_v.iter().map(|v| scalar.$op(*v)).collect::<Vec<f32>>();
+              Ok(Value::Tensor(Tensor::from_f32_slice(&res)))
+            }
+            Self::Null => Ok(Self::Null),
+            _ => Err(Error::InvalidBinaryOperands.into()),
+          },
+          Self::Tensor(lhs_v) => match rhs
+          {
+            Self::Tensor(rhs_v) =>
+            {
+              if lhs_v.len() != rhs_v.len()
+              {
+                Err(Error::InvalidBinaryOperands.into())
+              }
+              else
+              {
+                let res = lhs_v
+                  .iter()
+                  .zip(rhs_v.iter())
+                  .map(|(a, b)| (*a).$op(*b))
+                  .collect::<Vec<f32>>();
+                Ok(Value::Tensor(Tensor::from_f32_slice(&res)))
+              }
+            }
+            Self::Float(rhs) =>
+            {
+              let rhs_scalar = rhs as f32;
+              let res = lhs_v
+                .iter()
+                .map(|a| (*a).$op(rhs_scalar))
+                .collect::<Vec<f32>>();
+              Ok(Value::Tensor(Tensor::from_f32_slice(&res)))
+            }
+            Self::Integer(rhs) =>
+            {
+              let rhs_scalar = rhs as f32;
+              let res = lhs_v
+                .iter()
+                .map(|a| (*a).$op(rhs_scalar))
+                .collect::<Vec<f32>>();
+              Ok(Value::Tensor(Tensor::from_f32_slice(&res)))
+            }
             Self::Null => Ok(Self::Null),
             _ => Err(Error::InvalidBinaryOperands.into()),
           },
@@ -223,6 +406,7 @@ impl Value
       | Value::Edge(..)
       | Value::Array(..)
       | Value::Map(..)
+      | Value::SinglePath(..)
       | Value::Path(..) => Err(Error::InvalidBinaryOperands),
       Value::Null => Ok(Value::Null),
       Self::Float(lhs) => match rhs
@@ -243,6 +427,43 @@ impl Value
         Self::Null => Ok(Self::Null),
         _ => Err(Error::InvalidBinaryOperands),
       },
+      Self::Tensor(lhs_v) => match rhs
+      {
+        Self::Float(rhs) =>
+        {
+          let res = lhs_v
+            .iter()
+            .map(|a| a.powf(rhs as f32))
+            .collect::<Vec<f32>>();
+          Ok(Value::Tensor(Tensor::from_f32_slice(&res)))
+        }
+        Self::Integer(rhs) =>
+        {
+          let res = lhs_v
+            .iter()
+            .map(|a| a.powf(rhs as f32))
+            .collect::<Vec<f32>>();
+          Ok(Value::Tensor(Tensor::from_f32_slice(&res)))
+        }
+        Self::Tensor(rhs_v) =>
+        {
+          if lhs_v.len() != rhs_v.len()
+          {
+            Err(Error::InvalidBinaryOperands)
+          }
+          else
+          {
+            let res = lhs_v
+              .iter()
+              .zip(rhs_v.iter())
+              .map(|(a, b)| a.powf(*b))
+              .collect::<Vec<f32>>();
+            Ok(Value::Tensor(Tensor::from_f32_slice(&res)))
+          }
+        }
+        Self::Null => Ok(Self::Null),
+        _ => Err(Error::InvalidBinaryOperands),
+      },
     }
   }
 }
@@ -256,6 +477,7 @@ impl Neg for Value
     {
       Self::Float(fl) => Ok((-fl).into()),
       Self::Integer(i) => Ok((-i).into()),
+      Self::Tensor(t) => Ok(Value::Tensor(t.into_iter().map(|x| -x).collect())),
       Value::Null => Ok(Value::Null),
       Value::Boolean(..)
       | Value::Key(..)
@@ -265,6 +487,7 @@ impl Neg for Value
       | Value::TimeStamp(..)
       | Value::Array(..)
       | Value::Map(..)
+      | Value::SinglePath(..)
       | Value::Path(..) => Err(Error::InvalidNegationOperands),
     }
   }
@@ -284,9 +507,11 @@ impl std::fmt::Display for Value
       Value::String(s) => write!(f, "{}", s),
       Value::TimeStamp(t) => write!(f, "{}", t),
       Value::Array(v) => write!(f, "[{}]", v.iter().map(|x| x.to_string()).join(", ")),
+      Value::Tensor(v) => write!(f, "[{}]", v.iter().map(|x| x.to_string()).join(", ")),
       Value::Map(o) => write!(f, "{}", o),
       Value::Node(n) => write!(f, "{}", n),
       Value::Edge(e) => write!(f, "{}", e),
+      Value::SinglePath(p) => write!(f, "{}", p),
       Value::Path(p) => write!(f, "{}", p),
     }
   }
@@ -331,9 +556,26 @@ pub enum FromValueResult<T>
   Invalid(Value),
 }
 
+fn identity<T>(t: T) -> T
+{
+  t
+}
+fn boxed<T>(t: T) -> Box<T>
+{
+  Box::new(t)
+}
+
+// Suppression is needed because this function must take a
+// box as argument to be used in the macro bellow
+#[allow(clippy::boxed_local)]
+fn unboxed<T>(t: Box<T>) -> T
+{
+  *t
+}
+
 macro_rules! impl_from_value {
-  ($type:ty, $vn:tt, try) => {
-    impl_from_value!($type, $vn);
+  ($type:ty, $vn:tt, $factory: ident, $defactory: ident, try) => {
+    impl_from_value!($type, $vn, $factory, $defactory);
     impl TryFrom<Value> for $type
     {
       type Error = Error;
@@ -341,7 +583,7 @@ macro_rules! impl_from_value {
       {
         match value
         {
-          Value::$vn(v) => Ok(v),
+          Value::$vn(v) => Ok($defactory(v)),
           _ => Err(
             Error::InvalidValueCast {
               value: Box::new(value),
@@ -358,18 +600,18 @@ macro_rules! impl_from_value {
       {
         match value
         {
-          Value::$vn(v) => FromValueResult::Ok(v),
+          Value::$vn(v) => FromValueResult::Ok($defactory(v)),
           _ => FromValueResult::Invalid(value),
         }
       }
     }
   };
-  ($type:ty, $vn:tt) => {
+  ($type:ty, $vn:tt, $factory: ident, $defactory: ident) => {
     impl From<$type> for Value
     {
       fn from(v: $type) -> Value
       {
-        Value::$vn(v)
+        Value::$vn($factory(v))
       }
     }
 
@@ -432,17 +674,99 @@ macro_rules! impl_from_value {
   };
 }
 
-impl_from_value!(graph::Key, Key, try);
-impl_from_value!(bool, Boolean, try);
-impl_from_value!(i64, Integer, try);
-impl_from_value!(f64, Float);
-impl_from_value!(String, String, try);
-impl_from_value!(TimeStamp, TimeStamp);
-impl_from_value!(graph::Node, Node, try);
-impl_from_value!(graph::Edge, Edge, try);
-impl_from_value!(graph::SinglePath, Path, try);
-impl_from_value!(Vec<Value>, Array, try);
-impl_from_value!(ValueMap, Map, try);
+impl_from_value!(graph::Key, Key, identity, identity, try);
+impl_from_value!(bool, Boolean, identity, identity, try);
+impl_from_value!(i64, Integer, identity, identity, try);
+impl_from_value!(f64, Float, identity, identity);
+impl_from_value!(String, String, identity, identity, try);
+impl_from_value!(TimeStamp, TimeStamp, identity, identity);
+impl_from_value!(graph::Node, Node, identity, identity, try);
+impl_from_value!(graph::Edge, Edge, identity, identity, try);
+impl_from_value!(graph::SinglePath, SinglePath, boxed, unboxed, try);
+impl_from_value!(graph::Path, Path, boxed, unboxed, try);
+impl_from_value!(Vec<Value>, Array, identity, identity, try);
+impl_from_value!(ValueMap, Map, identity, identity, try);
+impl_from_value!(Tensor, Tensor, identity, identity);
+
+impl TryFrom<Value> for Tensor
+{
+  type Error = Error;
+  fn try_from(value: Value) -> Result<Tensor, Self::Error>
+  {
+    match value
+    {
+      Value::Tensor(v) => Ok(v),
+      Value::Array(arr) =>
+      {
+        let mut out = Vec::with_capacity(arr.len());
+        for v in arr.iter()
+        {
+          match v
+          {
+            Value::Float(f) => out.push(*f as f32),
+            Value::Integer(i) => out.push(*i as f32),
+            _ =>
+            {
+              return Err(Error::InvalidValueCast {
+                value: Box::new(Value::Array(arr.clone())),
+                typename: "Vec<f32>",
+              });
+            }
+          }
+        }
+        Ok(Tensor::from_f32_slice(&out))
+      }
+      _ => Err(Error::InvalidValueCast {
+        value: Box::new(value),
+        typename: "Vec<f32>",
+      }),
+    }
+  }
+}
+
+impl TryFrom<Value> for Vec<f32>
+{
+  type Error = Error;
+  fn try_from(value: Value) -> Result<Vec<f32>, Self::Error>
+  {
+    match value
+    {
+      Value::Tensor(t) => Ok(t.to_f32_vec()),
+      Value::Array(arr) =>
+      {
+        let mut out = Vec::with_capacity(arr.len());
+        for v in arr.iter()
+        {
+          match v
+          {
+            Value::Float(f) => out.push(*f as f32),
+            Value::Integer(i) => out.push(*i as f32),
+            _ =>
+            {
+              return Err(Error::InvalidValueCast {
+                value: Box::new(Value::Array(arr.clone())),
+                typename: "Vec<f32>",
+              });
+            }
+          }
+        }
+        Ok(out)
+      }
+      _ => Err(Error::InvalidValueCast {
+        value: Box::new(value),
+        typename: "Vec<f32>",
+      }),
+    }
+  }
+}
+
+impl From<Vec<f32>> for Value
+{
+  fn from(v: Vec<f32>) -> Value
+  {
+    Value::Tensor(Tensor::from(v))
+  }
+}
 
 impl TryFrom<Value> for f64
 {