gqlite 1.2.3 → 1.3.0

data/ext/{gqliterb/vendor/gqlitedb → graphcore}/src/graph.rs

@@ -3,19 +3,27 @@ use std::borrow::Borrow;
 
 use crate::prelude::*;
 
-#[derive(Debug, Clone, Copy)]
-pub(crate) enum EdgeDirectivity
-{
-  Undirected,
-  Directed,
-}
-
+/// Uuid of a graph element (node, edge...).
 #[derive(Debug, Eq, PartialEq, Clone, Copy, Hash)]
 pub struct Key
 {
   pub(crate) uuid: u128,
 }
 
+impl Key
+{
+  /// New key from a given uuid
+  pub fn new(uuid: u128) -> Self
+  {
+    Self { uuid }
+  }
+  /// Return the 128bits uuid value.
+  pub fn uuid(&self) -> u128
+  {
+    self.uuid
+  }
+}
+
 impl Serialize for Key
 {
   fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -79,6 +87,15 @@ pub struct Node
 
 impl Node
 {
+  /// Create a new node object
+  pub fn new(key: Key, labels: Vec<String>, properties: value::ValueMap) -> Node
+  {
+    Self {
+      key,
+      labels,
+      properties,
+    }
+  }
   /// uuid for the Node.
   pub fn key(&self) -> Key
   {
@@ -89,11 +106,33 @@ impl Node
   {
     &self.labels
   }
+  /// Mutable labels
+  pub fn labels_mut(&mut self) -> &mut Vec<String>
+  {
+    &mut self.labels
+  }
+  /// Edit labels
+  pub fn labels_edit(&mut self, editor: impl FnOnce(Vec<String>) -> Vec<String>)
+  {
+    let mut tmp = Default::default();
+    std::mem::swap(&mut self.labels, &mut tmp);
+    self.labels = editor(tmp);
+  }
   /// Properties.
   pub fn properties(&self) -> &value::ValueMap
   {
     &self.properties
   }
+  /// Properties.
+  pub fn take_properties(self) -> value::ValueMap
+  {
+    self.properties
+  }
+  /// Properties.
+  pub fn properties_mut(&mut self) -> &mut value::ValueMap
+  {
+    &mut self.properties
+  }
   /// Unpack Node in key, labels and properties.
   pub fn unpack(self) -> (Key, Vec<String>, value::ValueMap)
   {
@@ -102,7 +141,7 @@ impl Node
   /// Convert into value map representation
   pub fn into_value_map(self) -> value::ValueMap
   {
-    crate::map!("labels" => self.labels, "properties" => self.properties, "type" => "node")
+    crate::value_map!("key" => self.key, "labels" => self.labels, "properties" => self.properties, "type" => "node")
   }
 }
 
@@ -130,12 +169,6 @@ pub struct Edge
 {
   /// uuid for the Edge.
   pub(crate) key: Key,
-  #[serde(skip_serializing)]
-  /// source node for the Edge, this property is used internally by the engine, but is not exported in query results, and not part of the public API.
-  pub(crate) source: Node,
-  /// destination node for the Edge, this property is used internally by the engine, but is not exported in query results, and not part of the public API.
-  #[serde(skip_serializing)]
-  pub(crate) destination: Node,
   /// Labels for the Edge.
   pub(crate) labels: Vec<String>,
   /// Properties for the Edge.
@@ -144,6 +177,16 @@ pub struct Edge
 
 impl Edge
 {
+  /// Create a new node object
+  pub fn new(key: Key, labels: Vec<String>, properties: value::ValueMap) -> Edge
+  {
+    Self {
+      key,
+      labels,
+      properties,
+    }
+  }
+
   /// uuid for the Node.
   pub fn key(&self) -> Key
   {
@@ -154,11 +197,33 @@ impl Edge
   {
     &self.labels
   }
+  /// Mutable labels
+  pub fn labels_mut(&mut self) -> &mut Vec<String>
+  {
+    &mut self.labels
+  }
+  /// Edit labels
+  pub fn labels_edit(&mut self, editor: impl FnOnce(Vec<String>) -> Vec<String>)
+  {
+    let mut tmp = Default::default();
+    std::mem::swap(&mut self.labels, &mut tmp);
+    self.labels = editor(tmp);
+  }
   /// Properties.
   pub fn properties(&self) -> &value::ValueMap
   {
     &self.properties
   }
+  /// Properties.
+  pub fn properties_mut(&mut self) -> &mut value::ValueMap
+  {
+    &mut self.properties
+  }
+  /// Properties.
+  pub fn take_properties(self) -> value::ValueMap
+  {
+    self.properties
+  }
   /// Unpack Edge in key, labels and properties.
   pub fn unpack(self) -> (Key, Vec<String>, value::ValueMap)
   {
@@ -167,7 +232,7 @@ impl Edge
   /// Convert into value map representation
   pub fn into_value_map(self) -> value::ValueMap
   {
-    crate::map!( "labels" => self.labels, "properties" => self.properties, "type" => "edge")
+    crate::value_map!("key" => self.key,  "labels" => self.labels, "properties" => self.properties, "type" => "edge")
   }
 }
 
@@ -181,24 +246,10 @@ impl std::fmt::Display for Edge
   }
 }
 
-impl Into<Path> for Edge
-{
-  fn into(self) -> Path
-  {
-    Path {
-      key: self.key,
-      source: self.source,
-      destination: self.destination,
-      labels: self.labels,
-      properties: self.properties,
-    }
-  }
-}
-
-/// Path in the graph.
+/// SinglePath in the graph. A SinglePath contains an edge, source and destination.
 #[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone, Hash)]
 #[serde(tag = "type", rename = "path")]
-pub struct Path
+pub struct SinglePath
 {
   /// uuid for the path.
   pub(crate) key: Key,
@@ -212,8 +263,25 @@ pub struct Path
   pub(crate) properties: value::ValueMap,
 }
 
-impl Path
+impl SinglePath
 {
+  /// Create new single path
+  pub fn new(
+    key: Key,
+    source: Node,
+    labels: Vec<String>,
+    properties: value::ValueMap,
+    destination: Node,
+  ) -> SinglePath
+  {
+    SinglePath {
+      key,
+      source,
+      destination,
+      labels,
+      properties,
+    }
+  }
   /// uuid for the Node.
   pub fn key(&self) -> Key
   {
@@ -250,14 +318,32 @@ impl Path
       self.destination,
     )
   }
+  /// Convert into an Edge
+  pub fn to_edge(&self) -> Edge
+  {
+    Edge {
+      key: self.key,
+      labels: self.labels.clone(),
+      properties: self.properties.clone(),
+    }
+  }
+  /// Convert into an Edge
+  pub fn into_edge(self) -> Edge
+  {
+    Edge {
+      key: self.key,
+      labels: self.labels,
+      properties: self.properties,
+    }
+  }
   /// Convert into value map representation
   pub fn into_value_map(self) -> value::ValueMap
   {
-    crate::map!( "source" => self.source, "labels" => self.labels, "properties" => self.properties, "destination" => self.destination, "type" => "path")
+    crate::value_map!("key" => self.key, "source" => self.source, "labels" => self.labels, "properties" => self.properties, "destination" => self.destination, "type" => "path")
   }
 }
 
-impl std::fmt::Display for Path
+impl std::fmt::Display for SinglePath
 {
   fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
   {
@@ -267,7 +353,20 @@ impl std::fmt::Display for Path
   }
 }
 
-#[cfg(test)]
+impl From<SinglePath> for Edge
+{
+  fn from(val: SinglePath) -> Self
+  {
+    Edge {
+      key: val.key,
+      labels: val.labels,
+      properties: val.properties,
+    }
+  }
+}
+
+/// Convenient macro to create a vector of label, from &str.
+#[macro_export]
 macro_rules! labels {
   // match a list of expressions separated by comma:
   ($($str:expr),*) => (
@@ -278,6 +377,3 @@ macro_rules! labels {
     }
   );
 }
-
-#[cfg(test)]
-pub(crate) use labels;

data/ext/graphcore/src/lib.rs

@@ -0,0 +1,16 @@
+#![doc = include_str!("../README.MD")]
+#![warn(missing_docs)]
+#![deny(warnings)]
+#![allow(clippy::result_large_err)]
+
+mod error;
+mod graph;
+mod prelude;
+mod serialize_with;
+mod table;
+mod value;
+
+pub use error::Error;
+pub use graph::{Edge, Key, Node, SinglePath};
+pub use table::Table;
+pub use value::{Value, ValueMap, ValueTryIntoRef};

data/ext/graphcore/src/prelude.rs

@@ -0,0 +1,4 @@
+pub(crate) use crate::{error, graph, serialize_with, value};
+pub(crate) use error::Error;
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;

data/ext/{gqliterb/vendor/gqlitedb → graphcore}/src/serialize_with.rs

@@ -2,7 +2,7 @@ use serde::de::{self, Visitor};
 use serde::{Deserializer, Serializer};
 use std::fmt;
 
-const NAN: f64 = std::f64::NAN;
+const NAN: f64 = f64::NAN;
 
 pub fn serialize_float<S>(x: &f64, serializer: S) -> Result<S::Ok, S::Error>
 where
@@ -68,7 +68,7 @@ impl<'de> Visitor<'de> for FloatDeserializeVisitor
   where
     E: de::Error,
   {
-    Ok(v as f64)
+    Ok(v)
   }
 
   fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>

data/ext/graphcore/src/table.rs

@@ -0,0 +1,272 @@
+use crate::{prelude::*, Value, ValueTryIntoRef};
+
+/// Table of values
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct Table
+{
+  headers: Vec<String>,
+  data: Vec<crate::Value>,
+}
+
+impl Table
+{
+  /// Create a new table, with the given headers and data.
+  /// It is assumed that number of column is equalt to headers, and the number
+  /// of row is equal to length of data divided by number of columns.
+  pub fn new(headers: Vec<String>, data: Vec<crate::Value>) -> Result<Table>
+  {
+    if data.len() % headers.len() != 0
+    {
+      Err(error::Error::InvalidTableDimensions)?;
+    }
+    Ok(Table { headers, data })
+  }
+  /// Create an empty table
+  pub fn empty() -> Table
+  {
+    Table {
+      headers: Default::default(),
+      data: Default::default(),
+    }
+  }
+  /// Return true is empty
+  pub fn is_empty(&self) -> bool
+  {
+    self.data.is_empty()
+  }
+  /// Access to the headers of the table
+  pub fn headers(&self) -> &Vec<String>
+  {
+    &self.headers
+  }
+  /// number of rows
+  pub fn rows(&self) -> usize
+  {
+    self.data.len() / self.headers.len()
+  }
+  /// number of columns
+  pub fn columns(&self) -> usize
+  {
+    self.headers.len()
+  }
+  /// value access
+  pub fn get<T>(&self, row: usize, column: usize) -> Result<&T>
+  where
+    Value: ValueTryIntoRef<T>,
+  {
+    let v = self.value(row, column)?;
+    v.try_into_ref()
+  }
+  /// value access
+  pub fn get_owned<T>(&self, row: usize, column: usize) -> Result<T>
+  where
+    Value: ValueTryIntoRef<T>,
+    T: Clone,
+  {
+    let v = self.value(row, column)?;
+    v.try_into_ref().map(T::to_owned)
+  }
+  /// value access
+  pub fn value(&self, row: usize, column: usize) -> Result<&Value>
+  {
+    if column > self.headers.len()
+    {
+      Err(error::Error::InvalidRange)
+    }
+    else
+    {
+      self
+        .data
+        .get(row * self.headers.len() + column)
+        .ok_or(error::Error::InvalidRange)
+    }
+  }
+  /// Create an iterator over the rows in the table
+  pub fn row_iter(&self) -> RowIter<'_>
+  {
+    RowIter {
+      data: &self.data,
+      columns: self.columns(),
+      index: 0,
+      row_count: self.rows(),
+    }
+  }
+}
+
+impl From<Table> for value::Value
+{
+  fn from(val: Table) -> Self
+  {
+    let mut rows: Vec<value::Value> = Default::default();
+    let cl = val.headers.len();
+    rows.push(val.headers.into());
+    let mut it = val.data.into_iter();
+    loop
+    {
+      let first = it.next();
+      if let Some(first) = first
+      {
+        let mut row = Vec::with_capacity(cl);
+        row.push(first);
+        for _ in 1..cl
+        {
+          row.push(it.next().unwrap());
+        }
+        rows.push(row.into());
+      }
+      else
+      {
+        break;
+      }
+    }
+    rows.into()
+  }
+}
+
+/// View of a row
+#[derive(Debug)]
+pub struct RowView<'a>
+{
+  row: &'a [value::Value], // length = columns.len()
+}
+
+impl<'a> RowView<'a>
+{
+  /// Iterate over the value of the row view
+  pub fn iter(&self) -> std::slice::Iter<'a, value::Value>
+  {
+    self.row.iter()
+  }
+  /// value access
+  pub fn value(&self, column: usize) -> Result<&Value>
+  {
+    self.row.get(column).ok_or(error::Error::InvalidRange)
+  }
+  /// value access
+  pub fn get<T>(&self, column: usize) -> Result<&T>
+  where
+    Value: ValueTryIntoRef<T>,
+  {
+    let v = self.value(column)?;
+    v.try_into_ref()
+  }
+  /// value access
+  pub fn get_owned<T>(&self, column: usize) -> Result<T>
+  where
+    Value: ValueTryIntoRef<T>,
+    T: Clone,
+  {
+    let v = self.value(column)?;
+    v.try_into_ref().map(T::to_owned)
+  }
+}
+
+/// Iteratpr over rows of a table
+pub struct RowIter<'a>
+{
+  data: &'a Vec<value::Value>,
+  columns: usize,
+  index: usize,
+  row_count: usize,
+}
+
+impl<'a> Iterator for RowIter<'a>
+{
+  type Item = RowView<'a>;
+
+  fn next(&mut self) -> Option<Self::Item>
+  {
+    if self.columns == 0
+    {
+      if self.index < self.row_count
+      {
+        self.index += 1;
+        Some(RowView {
+          row: &self.data[0..0],
+        })
+      }
+      else
+      {
+        None
+      }
+    }
+    else
+    {
+      let start = self.index * self.columns;
+      let end = start + self.columns;
+
+      if self.columns == 0 || end > self.data.len()
+      {
+        return None;
+      }
+
+      let rv = RowView {
+        row: &self.data[start..end],
+      };
+
+      self.index += 1;
+
+      Some(rv)
+    }
+  }
+}
+
+/// Convenient macro for creating tables.
+///
+/// Example:
+///
+/// ```rust
+/// # use graphcore::{Table, table};
+/// let table: Table = table!(("a", "b"), [["row0", "row0"], ["row1", "row2"]]);
+/// ```
+#[macro_export]
+macro_rules! table {
+  () => (
+      $crate::Table::empty()
+  );
+  (($($header:expr),+ $(,)?), []) => (
+    $crate::Table::new(
+      vec![$($header.into()),+],
+      vec![]
+    ).unwrap()
+  );
+  (($($header:expr),+ $(,)?), [$([$($x:expr),+ $(,)?]),*]) => (
+    {
+      let headers = vec![$($header.into()),+];
+      let mut data = Vec::new();
+      $(
+          data.extend(vec![$($x.into()),+]);
+      )*
+      $crate::Table::new(headers, data).unwrap()
+    }
+  );
+}
+
+#[cfg(test)]
+mod tests
+{
+  use crate::Table;
+
+  #[test]
+  fn test_table_macro()
+  {
+    let tb = table!();
+    assert_eq!(tb, Table::empty());
+    let tb = table!(("a", "b"), []);
+    assert_eq!(tb.rows(), 0);
+    assert_eq!(tb.columns(), 2);
+    assert_eq!(*tb.headers(), vec!["a".to_string(), "b".to_string()]);
+    let tb = table!(("a", "b"), [[1, 2], [3, 4]]);
+    assert_eq!(tb.rows(), 2);
+    assert_eq!(tb.columns(), 2);
+    assert_eq!(*tb.headers(), vec!["a".to_string(), "b".to_string()]);
+    assert_eq!(*tb.value(0, 0).unwrap(), 1.into());
+    assert_eq!(*tb.value(0, 1).unwrap(), 2.into());
+    assert_eq!(*tb.value(1, 0).unwrap(), 3.into());
+    assert_eq!(*tb.value(1, 1).unwrap(), 4.into());
+    assert_eq!(*tb.get::<i64>(0, 0).unwrap(), 1);
+    assert_eq!(*tb.get::<i64>(0, 1).unwrap(), 2);
+    assert_eq!(*tb.get::<i64>(1, 0).unwrap(), 3);
+    assert_eq!(*tb.get::<i64>(1, 1).unwrap(), 4);
+  }
+}