gqlite 1.5.0 → 1.7.0

data/ext/gqlparser/src/oc.rs

@@ -0,0 +1,33 @@
+//! OpenCypher parser
+
+use nom::Finish;
+
+pub mod ast;
+mod error;
+mod lexer;
+mod parser;
+
+pub use error::{Error, ErrorKind};
+
+/// Result type used by this crate
+pub type Result<T, E = error::Error> = std::result::Result<T, E>;
+
+/// Parse an OpenCypher into an AST.
+pub fn parse_oc_query(source: &str) -> Result<ast::Queries>
+{
+  let context = parser::Context::new(source);
+  let tokens = lexer::tokenize(source)?;
+  let input = parser::Input(&tokens, &context);
+  // Parse schema
+  let (rem, parse_tree) = parser::queries(input.clone()).finish()?;
+
+  if !rem.0.is_empty()
+  {
+    return Err(Error::new(
+      error::ErrorKind::UnexpectedToken,
+      rem.first().map_or(Default::default(), |x| x.span.clone()),
+    ));
+  }
+
+  Ok(parse_tree)
+}

data/ext/gqlparser/src/prelude.rs

@@ -0,0 +1,3 @@
+//! Import this prelude for base types
+
+pub use crate::{gqls, oc};

data/ext/graphcore/Cargo.toml

@@ -15,6 +15,7 @@ jiff = { version = "0.2" }
 serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }
 uuid = { workspace = true }
+bytemuck = "1"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 uuid = { version = "1", features = ["js"] }

data/ext/graphcore/src/error.rs

@@ -27,4 +27,30 @@ pub enum Error
   InvalidRange,
   #[error("TimeStamp error {0}.")]
   TimeError(#[from] jiff::Error),
+  #[error("QueryExecutionError {0}.")]
+  QueryExecutionError(String),
+  // Tensor decode errors
+  #[error("Tensor decode: too short")]
+  TensorTooShort,
+  #[error("Tensor decode: unknown version {0}")]
+  TensorUnknownVersion(u8),
+  #[error("Tensor decode: unknown flags {0}")]
+  TensorUnknownFlags(u8),
+  #[error("Tensor decode: unknown dtype {0}")]
+  TensorUnknownDType(u8),
+  #[error("Tensor decode: numel overflow")]
+  TensorNumelOverflow,
+  #[error("Tensor decode: data length mismatch")]
+  TensorDataLengthMismatch,
+  // Tensor shape errors
+  #[error("Tensor: rank too large")]
+  TensorRankTooLarge,
+  #[error("Tensor: dimension too large")]
+  TensorDimensionTooLarge,
+  #[error("Tensor: numel overflow")]
+  TensorShapeNumelOverflow,
+  #[error("Tensor: data length mismatch")]
+  TensorShapeDataLengthMismatch,
+  #[error("Tensor: shape mismatch")]
+  TensorShapeMismatch,
 }

data/ext/graphcore/src/graph.rs

@@ -3,6 +3,17 @@ use std::borrow::Borrow;
 
 use crate::prelude::*;
 
+/// Directivity of an edge, usually used in query to indicate the matching
+/// direction is not important.
+#[derive(Debug, Clone, Copy)]
+pub enum EdgeDirectivity
+{
+  /// Undirected edge
+  Undirected,
+  /// Directed edge
+  Directed,
+}
+
 /// Uuid of a graph element (node, edge...).
 #[derive(Debug, Eq, PartialEq, Clone, Copy, Hash)]
 pub struct Key
@@ -77,6 +88,8 @@ impl From<Key> for u128
 #[serde(tag = "type", rename = "node")]
 pub struct Node
 {
+  /// Name of the graph.
+  pub(crate) graph_name: Option<String>,
   /// uuid for the Node.
   pub(crate) key: Key,
   /// Vector of labels.
@@ -88,14 +101,31 @@ pub struct Node
 impl Node
 {
   /// Create a new node object
-  pub fn new(key: Key, labels: Vec<String>, properties: value::ValueMap) -> Node
+  pub fn new(
+    graph_name: Option<String>,
+    key: Key,
+    labels: Vec<String>,
+    properties: value::ValueMap,
+  ) -> Node
   {
     Self {
+      graph_name,
       key,
       labels,
       properties,
     }
   }
+  /// Name of the graph that contains the path
+  pub fn graph_name(&self) -> &Option<String>
+  {
+    &self.graph_name
+  }
+  /// Set the graph name
+  pub fn with_graph_name(mut self, graph_name: impl Into<String>) -> Self
+  {
+    self.graph_name = Some(graph_name.into());
+    self
+  }
   /// uuid for the Node.
   pub fn key(&self) -> Key
   {
@@ -134,9 +164,9 @@ impl Node
     &mut self.properties
   }
   /// Unpack Node in key, labels and properties.
-  pub fn unpack(self) -> (Key, Vec<String>, value::ValueMap)
+  pub fn unpack(self) -> (Option<String>, Key, Vec<String>, value::ValueMap)
   {
-    (self.key, self.labels, self.properties)
+    (self.graph_name, self.key, self.labels, self.properties)
   }
   /// Convert into value map representation
   pub fn into_value_map(self) -> value::ValueMap
@@ -162,11 +192,21 @@ impl std::fmt::Display for Node
   }
 }
 
+impl AsRef<Node> for Node
+{
+  fn as_ref(&self) -> &Node
+  {
+    self
+  }
+}
+
 /// Directed edge of the graph.
 #[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone, Hash)]
 #[serde(tag = "type", rename = "edge")]
 pub struct Edge
 {
+  /// Name of the graph.
+  pub(crate) graph_name: Option<String>,
   /// uuid for the Edge.
   pub(crate) key: Key,
   /// Labels for the Edge.
@@ -178,15 +218,32 @@ pub struct Edge
 impl Edge
 {
   /// Create a new node object
-  pub fn new(key: Key, labels: Vec<String>, properties: value::ValueMap) -> Edge
+  pub fn new(
+    graph_name: Option<String>,
+    key: Key,
+    labels: Vec<String>,
+    properties: value::ValueMap,
+  ) -> Edge
   {
     Self {
+      graph_name,
       key,
       labels,
       properties,
     }
   }
 
+  /// Name of the graph that contains the path
+  pub fn graph_name(&self) -> &Option<String>
+  {
+    &self.graph_name
+  }
+  /// Set the graph name
+  pub fn with_graph_name(mut self, graph_name: impl Into<String>) -> Self
+  {
+    self.graph_name = Some(graph_name.into());
+    self
+  }
   /// uuid for the Node.
   pub fn key(&self) -> Key
   {
@@ -225,9 +282,9 @@ impl Edge
     self.properties
   }
   /// Unpack Edge in key, labels and properties.
-  pub fn unpack(self) -> (Key, Vec<String>, value::ValueMap)
+  pub fn unpack(self) -> (Option<String>, Key, Vec<String>, value::ValueMap)
   {
-    (self.key, self.labels, self.properties)
+    (self.graph_name, self.key, self.labels, self.properties)
   }
   /// Convert into value map representation
   pub fn into_value_map(self) -> value::ValueMap
@@ -251,41 +308,43 @@ impl std::fmt::Display for Edge
 #[serde(tag = "type", rename = "path")]
 pub struct SinglePath
 {
-  /// uuid for the path.
-  pub(crate) key: Key,
   /// source node for the path.
   pub(crate) source: Node,
   /// destination node for the path.
   pub(crate) destination: Node,
-  /// Labels for the path.
-  pub(crate) labels: Vec<String>,
-  /// Properties for the path.
-  pub(crate) properties: value::ValueMap,
+  /// Edge for the path
+  pub(crate) edge: Edge,
 }
 
 impl SinglePath
 {
   /// Create new single path
-  pub fn new(
-    key: Key,
-    source: Node,
-    labels: Vec<String>,
-    properties: value::ValueMap,
-    destination: Node,
-  ) -> SinglePath
+  pub fn new(source: Node, edge: Edge, destination: Node) -> SinglePath
   {
     SinglePath {
-      key,
       source,
+      edge,
       destination,
-      labels,
-      properties,
     }
   }
+  /// Name of the graph that contains the path
+  pub fn graph_name(&self) -> &Option<String>
+  {
+    &self.edge.graph_name
+  }
+  /// Set the graph name
+  pub fn with_graph_name(mut self, graph_name: impl Into<String>) -> Self
+  {
+    let graph_name = graph_name.into();
+    self.source.graph_name = Some(graph_name.clone());
+    self.edge.graph_name = Some(graph_name.clone());
+    self.destination.graph_name = Some(graph_name);
+    self
+  }
   /// uuid for the Node.
   pub fn key(&self) -> Key
   {
-    self.key
+    self.edge.key
   }
   /// uuid for the Node.
   pub fn source(&self) -> &Node
@@ -300,46 +359,32 @@ impl SinglePath
   /// Vector of labels.
   pub fn labels(&self) -> &Vec<String>
   {
-    &self.labels
+    &self.edge.labels
   }
   /// Properties.
   pub fn properties(&self) -> &value::ValueMap
   {
-    &self.properties
+    &self.edge.properties
   }
   /// Unpack Node in key, labels and properties.
-  pub fn unpack(self) -> (Key, Node, Vec<String>, value::ValueMap, Node)
+  pub fn unpack(self) -> (Node, Edge, Node)
   {
-    (
-      self.key,
-      self.source,
-      self.labels,
-      self.properties,
-      self.destination,
-    )
+    (self.source, self.edge, self.destination)
   }
   /// Convert into an Edge
   pub fn to_edge(&self) -> Edge
   {
-    Edge {
-      key: self.key,
-      labels: self.labels.clone(),
-      properties: self.properties.clone(),
-    }
+    self.edge.clone()
   }
   /// Convert into an Edge
   pub fn into_edge(self) -> Edge
   {
-    Edge {
-      key: self.key,
-      labels: self.labels,
-      properties: self.properties,
-    }
+    self.edge
   }
   /// Convert into value map representation
   pub fn into_value_map(self) -> value::ValueMap
   {
-    crate::value_map!("key" => self.key, "source" => self.source, "labels" => self.labels, "properties" => self.properties, "destination" => self.destination, "type" => "path")
+    crate::value_map!("graph_name" => self.edge.graph_name, "key" => self.edge.key, "source" => self.source, "labels" => self.edge.labels, "properties" => self.edge.properties, "destination" => self.destination, "type" => "path")
   }
 }
 
@@ -347,9 +392,7 @@ impl std::fmt::Display for SinglePath
 {
   fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
   {
-    write!(f, "{}-[:{} ", self.source, self.labels.join(":"))?;
-    write!(f, "{}", self.properties.borrow())?;
-    write!(f, "])->{}", self.destination)
+    write!(f, "{}-{}->{} ", self.source, self.edge, self.destination)
   }
 }
 
@@ -357,11 +400,94 @@ impl From<SinglePath> for Edge
 {
   fn from(val: SinglePath) -> Self
   {
-    Edge {
-      key: val.key,
-      labels: val.labels,
-      properties: val.properties,
+    val.into_edge()
+  }
+}
+
+impl From<Box<SinglePath>> for Edge
+{
+  fn from(val: Box<SinglePath>) -> Self
+  {
+    val.into_edge()
+  }
+}
+
+/// Path in the graph. A Path contains a source, and multiple edges and destinations.
+#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone, Hash)]
+#[serde(tag = "type", rename = "path")]
+pub struct Path
+{
+  /// source node for the path.
+  pub(crate) source: Node,
+  // elements of the path
+  pub(crate) elements: Vec<(Edge, Node)>,
+}
+
+impl Path
+{
+  /// Create new single path
+  pub fn new(source: Node, elements: Vec<(Edge, Node)>) -> Path
+  {
+    Path { source, elements }
+  }
+  /// Name of the graph that contains the path
+  pub fn graph_name(&self) -> &Option<String>
+  {
+    &self.source.graph_name
+  }
+  /// Set the graph name
+  pub fn with_graph_name(mut self, graph_name: impl Into<String>) -> Self
+  {
+    let graph_name = graph_name.into();
+    self.source.graph_name = Some(graph_name.clone());
+    for (edge, destination) in self.elements.iter_mut()
+    {
+      edge.graph_name = Some(graph_name.clone());
+      destination.graph_name = Some(graph_name.clone());
+    }
+    self
+  }
+  /// Source for the Path.
+  pub fn source(&self) -> &Node
+  {
+    &self.source
+  }
+  /// Elements of the Path.
+  pub fn elements(&self) -> &Vec<(Edge, Node)>
+  {
+    &self.elements
+  }
+  /// Number of hops (edges) in the path.
+  pub fn elements_count(&self) -> usize
+  {
+    self.elements.len()
+  }
+  /// Unpack Node in key, labels and properties.
+  pub fn unpack(self) -> (Node, Vec<(Edge, Node)>)
+  {
+    (self.source, self.elements)
+  }
+  /// Convert into value map representation
+  pub fn into_value_map(self) -> value::ValueMap
+  {
+    crate::value_map!("source" => self.source, "elements" => self.elements.into_iter().map(|(e,d)|
+        {
+          crate::value_map!("edge" => e.into_value_map(), "destination" => d.into_value_map())
+        }
+    ).collect::<Vec<_>>())
+  }
+}
+
+impl std::fmt::Display for Path
+{
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
+  {
+    write!(f, "{}", self.source)?;
+    for (edge, destination) in self.elements.iter()
+    {
+      write!(f, "-{}->{} ", edge, destination)?;
     }
+    Ok(())
   }
 }
 

data/ext/graphcore/src/lib.rs

@@ -4,6 +4,7 @@
 
 mod error;
 mod graph;
+mod open_cypher;
 mod prelude;
 mod serialize_with;
 mod table;
@@ -11,7 +12,8 @@ mod timestamp;
 mod value;
 
 pub use error::Error;
-pub use graph::{Edge, Key, Node, SinglePath};
+pub use graph::{Edge, EdgeDirectivity, Key, Node, Path, SinglePath};
+pub use open_cypher::OpenCypherQueryExecutor;
 pub use table::Table;
 pub use timestamp::TimeStamp;
-pub use value::{FromValueResult, Value, ValueMap, ValueTryIntoRef};
+pub use value::{DType, FromValueResult, Tensor, Value, ValueMap, ValueTryIntoRef};

data/ext/graphcore/src/open_cypher.rs

@@ -0,0 +1,12 @@
+use crate::prelude::*;
+
+/// Trait for executing OpenCypher queries
+pub trait OpenCypherQueryExecutor
+{
+  /// Execute an OpenCypher query on the database.
+  fn execute_oc_query(
+    &self,
+    query: &str,
+    parameters: crate::ValueMap,
+  ) -> Result<Option<crate::Table>, crate::Error>;
+}

data/ext/graphcore/src/table.rs

@@ -1,4 +1,4 @@
-use crate::{prelude::*, Value, ValueTryIntoRef};
+use crate::{Value, ValueTryIntoRef, prelude::*};
 
 /// Table of values
 #[derive(Debug, Default, Clone, PartialEq)]
@@ -81,6 +81,18 @@ impl Table
         .ok_or(error::Error::InvalidRange)
     }
   }
+  /// Transform into an iterator over the rows in the table
+  pub fn into_row_iter(self) -> IntoRowIter
+  {
+    let columns = self.columns();
+    let row_count = self.rows();
+    IntoRowIter {
+      data: self.data.into_iter(),
+      columns,
+      index: 0,
+      row_count,
+    }
+  }
   /// Create an iterator over the rows in the table
   pub fn row_iter(&self) -> RowIter<'_>
   {
@@ -161,7 +173,43 @@ impl<'a> RowView<'a>
   }
 }
 
-/// Iteratpr over rows of a table
+/// Iterator over rows of a table
+pub struct IntoRowIter
+{
+  data: std::vec::IntoIter<value::Value>,
+  columns: usize,
+  /// index used to output empty rows, when columns is 0
+  index: usize,
+  row_count: usize,
+}
+
+impl Iterator for IntoRowIter
+{
+  type Item = Vec<value::Value>;
+
+  fn next(&mut self) -> Option<Self::Item>
+  {
+    if self.columns == 0
+    {
+      if self.index < self.row_count
+      {
+        self.index += 1;
+        Some(Default::default())
+      }
+      else
+      {
+        None
+      }
+    }
+    else
+    {
+      let v: Vec<_> = self.data.by_ref().take(self.columns).collect();
+      if v.is_empty() { None } else { Some(v) }
+    }
+  }
+}
+
+/// Iterator over rows of a table
 pub struct RowIter<'a>
 {
   data: &'a Vec<value::Value>,