gqlite 1.3.0 → 1.4.0

data/ext/gqlitedb/src/store.rs

@@ -1,13 +1,15 @@
-#[cfg(feature = "_pgql")]
-pub(crate) mod pgql;
+#[cfg(any(feature = "sqlite", feature = "postgres", feature = "_pgrx"))]
+pub(crate) mod sqlbase;
+
+#[cfg(feature = "_pgrx")]
+pub(crate) mod pgrx;
+#[cfg(feature = "postgres")]
+pub(crate) mod postgres;
 #[cfg(feature = "redb")]
 pub(crate) mod redb;
 #[cfg(feature = "sqlite")]
 pub(crate) mod sqlite;
 
-#[cfg(feature = "_pgql")]
-pub(crate) use pgql::Store;
-
 use crate::prelude::*;
 
 //  ____  _        _   _     _   _

data/ext/gqlitedb/src/tests/templates/programs.rs

@@ -71,7 +71,7 @@ pub(crate) fn create_named_node() -> Program
         skip: None,
         order_by: vec![],
       },
-      variables_size: create_variable_size(2, 0),
+      variables_sizes: create_variable_size(2, 0),
     },
   ]
 }
@@ -133,7 +133,7 @@ pub(crate) fn create_named_node_double_return() -> Program
         skip: None,
         order_by: vec![],
       },
-      variables_size: create_variable_size(3, 0),
+      variables_sizes: create_variable_size(3, 0),
     },
   ]
 }
@@ -161,7 +161,7 @@ pub(crate) fn double_with_return() -> Program
         skip: None,
         order_by: vec![],
       },
-      variables_size: create_variable_size(2, 0),
+      variables_sizes: create_variable_size(2, 0),
     },
     Block::With {
       variables: vec![
@@ -182,7 +182,7 @@ pub(crate) fn double_with_return() -> Program
         skip: None,
         order_by: vec![],
       },
-      variables_size: create_variable_size(4, 0),
+      variables_sizes: create_variable_size(4, 0),
     },
     Block::Return {
       variables: vec![(
@@ -199,7 +199,7 @@ pub(crate) fn double_with_return() -> Program
         skip: None,
         order_by: vec![],
       },
-      variables_size: create_variable_size(2, 0),
+      variables_sizes: create_variable_size(2, 0),
     },
   ]
 }
@@ -234,7 +234,7 @@ pub(crate) fn unwind() -> Program
         skip: None,
         order_by: vec![],
       },
-      variables_size: create_variable_size(1, 0),
+      variables_sizes: create_variable_size(1, 0),
     },
   ]
 }
@@ -288,7 +288,7 @@ pub(crate) fn match_loop() -> Program
         skip: None,
         order_by: vec![],
       },
-      variables_size: create_variable_size(1, 0),
+      variables_sizes: create_variable_size(1, 0),
     },
   ]
 }
@@ -327,7 +327,7 @@ pub(crate) fn optional_match() -> Program
         skip: None,
         order_by: vec![],
       },
-      variables_size: create_variable_size(1, 0),
+      variables_sizes: create_variable_size(1, 0),
     },
   ]
 }
@@ -378,7 +378,7 @@ pub(crate) fn match_count(function_manager: &functions::Manager) -> Program
         skip: None,
         order_by: vec![],
       },
-      variables_size: create_variable_size(2, 1),
+      variables_sizes: create_variable_size(2, 1),
     },
   ]
 }
@@ -449,7 +449,7 @@ pub(crate) fn aggregation(function_manager: &functions::Manager) -> Program
         skip: None,
         order_by: vec![],
       },
-      variables_size: create_variable_size(3, 1),
+      variables_sizes: create_variable_size(3, 1),
     },
   ]
 }

data/ext/gqlitedb/src/utils.rs

@@ -2,6 +2,8 @@ use std::fmt::{Debug, Display};
 
 use serde::{Deserialize, Serialize};
 
+use crate::prelude::*;
+
 #[derive(Serialize, Deserialize)]
 pub struct Version
 {
@@ -26,3 +28,26 @@ impl Display for Version
     f.write_fmt(format_args!("{}.{}.{}", self.major, self.minor, self.patch))
   }
 }
+
+pub(crate) fn hex(key: impl Into<graph::Key>) -> String
+{
+  format!("{:032X}", key.into().uuid())
+}
+
+#[cfg(test)]
+mod tests
+{
+  use crate::prelude::*;
+  #[test]
+  fn test_hex()
+  {
+    assert_eq!(
+      super::hex(graph::Key::new(18580062510968287067562660977870108180)),
+      "0DFA63CEE7484B0DBFC407697F77F614"
+    );
+    assert_eq!(
+      super::hex(graph::Key::new(0)),
+      "00000000000000000000000000000000"
+    );
+  }
+}

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

@@ -111,6 +111,12 @@ pub(crate) fn compare(lhs: &value::Value, rhs: &value::Value) -> Ordering
       Value::Null => Ordering::ComparedNull,
       _ => Ordering::Null,
     },
+    Value::TimeStamp(tl) => match rhs
+    {
+      Value::TimeStamp(tr) => tl.cmp(tr).into(),
+      Value::Null => Ordering::ComparedNull,
+      _ => Ordering::Null,
+    },
     Value::Array(al) => match rhs
     {
       Value::Array(ar) =>

data/ext/gqlitedb/src/value.rs

@@ -4,7 +4,7 @@ mod contains;
 pub(crate) use compare::{compare, Ordering};
 pub(crate) use contains::{contains, ContainResult};
 
-pub use graphcore::{array, value_map, Value, ValueMap, ValueTryIntoRef};
+pub use graphcore::{array, value_map, TimeStamp, Value, ValueMap, ValueTryIntoRef};
 
 pub(crate) trait ValueExt
 {
@@ -134,7 +134,7 @@ impl ValueExt for Value
         Value::String(rhs) => lhs.cmp(rhs),
         _ => std::cmp::Ordering::Greater,
       },
-      Value::Path(lhs) => match rhs
+      Value::TimeStamp(lhs) => match rhs
       {
         Value::Null
         | Value::Key(..)
@@ -142,6 +142,18 @@ impl ValueExt for Value
         | Value::Float(..)
         | Value::Boolean(..)
         | Value::String(..) => std::cmp::Ordering::Less,
+        Value::TimeStamp(rhs) => lhs.cmp(rhs),
+        _ => std::cmp::Ordering::Greater,
+      },
+      Value::Path(lhs) => match rhs
+      {
+        Value::Null
+        | Value::Key(..)
+        | Value::Integer(..)
+        | Value::Float(..)
+        | Value::Boolean(..)
+        | Value::String(..)
+        | Value::TimeStamp(..) => std::cmp::Ordering::Less,
         Value::Path(rhs) =>
         {
           match orderability_map(lhs.source().properties(), rhs.source().properties())
@@ -170,6 +182,7 @@ impl ValueExt for Value
         | Value::Float(..)
         | Value::Boolean(..)
         | Value::String(..)
+        | Value::TimeStamp(..)
         | Value::Path(..) => std::cmp::Ordering::Less,
         Value::Array(rhs) => lhs
           .iter()
@@ -187,6 +200,7 @@ impl ValueExt for Value
         | Value::Float(..)
         | Value::Boolean(..)
         | Value::String(..)
+        | Value::TimeStamp(..)
         | Value::Path(..)
         | Value::Array(..) => std::cmp::Ordering::Less,
         Value::Edge(rhs) => orderability_map(lhs.properties(), rhs.properties()),
@@ -200,6 +214,7 @@ impl ValueExt for Value
         | Value::Float(..)
         | Value::Boolean(..)
         | Value::String(..)
+        | Value::TimeStamp(..)
         | Value::Path(..)
         | Value::Array(..)
         | Value::Edge(..) => std::cmp::Ordering::Less,
@@ -214,6 +229,7 @@ impl ValueExt for Value
         | Value::Float(..)
         | Value::Boolean(..)
         | Value::String(..)
+        | Value::TimeStamp(..)
         | Value::Path(..)
         | Value::Array(..)
         | Value::Edge(..)

data/ext/gqlitedb/templates/sql/sqlite/edge_select.sql

@@ -17,22 +17,22 @@ JOIN gqlite_{{ graph_name }}_nodes AS n_left  ON e.left  = n_left.id
 JOIN gqlite_{{ graph_name }}_nodes AS n_right ON e.right = n_right.id
 WHERE
     -- Filter by key list (if not empty)
-    {% if has_edge_keys %}
+    {% if let Some(edge_keys_var) = edge_keys_var %}
     (
         hex(e.edge_key) IN (
-            SELECT value FROM json_each(:edge_keys)
+            SELECT value FROM json_each(?{{ edge_keys_var }})
         )
     )
     {% else %}
     1
     {% endif %}
     AND
-    {% if has_edge_labels %}
+    {% if let Some(edge_labels_var) = edge_labels_var %}
     -- Filter by required labels (must all be in e.labels)
     (
         NOT EXISTS (
             SELECT 1
-            FROM json_each(:edge_labels) AS required_label
+            FROM json_each(?{{ edge_labels_var }}) AS required_label
             WHERE NOT EXISTS (
                 SELECT 1
                 FROM json_each(e.labels) AS edge_label
@@ -44,11 +44,11 @@ WHERE
     1
     {% endif %}
     AND
-    {% if has_edge_properties %}
+    {% if let Some(edge_properties_var) = edge_properties_var %}
     -- Filter by required properties (must all exist and match)
         NOT EXISTS (
             SELECT 1
-            FROM json_each(:edge_properties) AS required_prop
+            FROM json_each(?{{ edge_properties_var }}) AS required_prop
             WHERE json_extract(e.properties, '$.' || required_prop.key) IS NULL
                 OR json_extract(e.properties, '$.' || required_prop.key) != required_prop.value
         )
@@ -57,22 +57,22 @@ WHERE
     {% endif %}
     -- Filter by key list (if not empty)
     AND
-    {% if has_n_left_keys %}
+    {% if let Some(left_keys_var) = left_keys_var %}
     (
         hex(n_left.node_key) IN (
-              SELECT value FROM json_each(:n_left_keys)
+              SELECT value FROM json_each(?{{ left_keys_var }})
         )
     )
     {% else %}
         1
     {% endif %}
     AND
-    {% if has_n_left_labels %}
+    {% if let Some(left_labels_var) = left_labels_var %}
     -- Filter by required labels (must all be in n_left.labels)
     (
         NOT EXISTS (
             SELECT 1
-            FROM json_each(:n_left_labels) AS required_label
+            FROM json_each(?{{ left_labels_var }}) AS required_label
             WHERE NOT EXISTS (
                 SELECT 1
                 FROM json_each(n_left.labels) AS node_label
@@ -84,12 +84,12 @@ WHERE
     1
     {% endif %}
     AND 
-    {% if has_n_left_properties %}
+    {% if let Some(left_properties_var) = left_properties_var %}
     -- Filter by required properties (must all exist and match)
     (
         NOT EXISTS (
             SELECT 1
-            FROM json_each(:n_left_properties) AS required_prop
+            FROM json_each(?{{ left_properties_var }}) AS required_prop
             WHERE json_extract(n_left.properties, '$.' || required_prop.key) IS NULL
                OR json_extract(n_left.properties, '$.' || required_prop.key) != required_prop.value
         )
@@ -99,22 +99,22 @@ WHERE
     {% endif %}
     AND
     -- Filter by key list (if not empty)
-    {% if has_n_right_keys %}
+    {% if let Some(right_keys_var) = right_keys_var %}
     (
         hex(n_right.node_key) IN (
-            SELECT value FROM json_each(:n_right_keys)
+            SELECT value FROM json_each(?{{ right_keys_var }})
         )
     )
     {% else %}
     1
     {% endif %}
     AND
-    {% if has_n_right_labels %}
+    {% if let Some(right_labels_var) = right_labels_var %}
     -- Filter by required labels (must all be in n_right.labels)
     (
         NOT EXISTS (
             SELECT 1
-            FROM json_each(:n_right_labels) AS required_label
+            FROM json_each(?{{ right_labels_var }}) AS required_label
             WHERE NOT EXISTS (
                 SELECT 1
                 FROM json_each(n_right.labels) AS node_label
@@ -126,12 +126,12 @@ WHERE
     1
     {% endif %}
 
-    {% if has_n_right_properties %}
+    {% if let Some(right_properties_var) = right_properties_var %}
     -- Filter by required properties (must all exist and match)
     AND (
         NOT EXISTS (
             SELECT 1
-            FROM json_each(:n_right_properties) AS required_prop
+            FROM json_each(?{{ right_properties_var }}) AS required_prop
             WHERE json_extract(n_right.properties, '$.' || required_prop.key) IS NULL
                OR json_extract(n_right.properties, '$.' || required_prop.key) != required_prop.value
         )

data/ext/gqlitedb/templates/sql/sqlite/edge_update.sql

@@ -1,4 +1,4 @@
 UPDATE gqlite_{{ graph_name }}_edges
-SET labels = :labels,
-    properties = :properties
-WHERE edge_key = :key;
+SET labels = ?2,
+    properties = ?3
+WHERE edge_key = ?1;

data/ext/gqlitedb/templates/sql/sqlite/node_select.sql

@@ -2,22 +2,22 @@ SELECT node_key, labels, properties
 FROM gqlite_{{ graph_name }}_nodes AS nodes
 WHERE
     -- Filter by key list (if not empty)
-    {% if has_keys %}
+    {% if let Some(keys_var) = keys_var %}
     (
         hex(nodes.node_key) IN (
-            SELECT value FROM json_each(:keys)
+            SELECT value FROM json_each(?{{ keys_var }})
         )
     )
     {% else %}
     1
     {% endif %}
     AND
-    {% if has_labels %}
+    {% if let Some(labels_var) = labels_var %}
     -- Filter by required labels (must all be in nodes.labels)
     (
         NOT EXISTS (
             SELECT 1
-            FROM json_each(:labels) AS required_label
+            FROM json_each(?{{ labels_var }}) AS required_label
             WHERE NOT EXISTS (
                 SELECT 1
                 FROM json_each(nodes.labels) AS node_label
@@ -29,12 +29,12 @@ WHERE
     1
     {% endif %}
 
-    {% if has_properties %}
+    {% if let Some(properties_var) = properties_var %}
     -- Filter by required properties (must all exist and match)
     AND (
         NOT EXISTS (
             SELECT 1
-            FROM json_each(:properties) AS required_prop
+            FROM json_each(?{{ properties_var }}) AS required_prop
             WHERE json_extract(nodes.properties, '$.' || required_prop.key) IS NULL
                OR json_extract(nodes.properties, '$.' || required_prop.key) != required_prop.value
         )

data/ext/gqlitedb/templates/sql/sqlite/node_update.sql

@@ -1,4 +1,4 @@
 UPDATE gqlite_{{ graph_name }}_nodes
-SET labels = :labels,
-    properties = :properties
-WHERE node_key = :key;
+SET labels = ?2,
+    properties = ?3
+WHERE node_key = ?1;

data/ext/gqliterb/src/lib.rs

@@ -1,7 +1,6 @@
-#![deny(warnings)]
-
 use std::fmt::Display;
 
+use gqlitedb::TimeStamp;
 use magnus::{
   function, method,
   prelude::*,
@@ -47,6 +46,22 @@ fn from_rvalue(ruby: &Ruby, value: magnus::Value) -> Result<gqlitedb::Value, Err
   {
     Ok(String::try_convert(value)?.into())
   }
+  else if value.is_kind_of(ruby.class_time())
+  {
+    let time = magnus::Time::try_convert(value)?;
+    let timespec = time.timespec()?;
+    Ok(
+      map_err(
+        ruby,
+        TimeStamp::from_unix_timestamp(
+          timespec.tv_sec,
+          timespec.tv_nsec as i32,
+          time.utc_offset() as i32,
+        ),
+      )?
+      .into(),
+    )
+  }
   else if value.is_kind_of(ruby.class_hash())
   {
     Ok(from_rhash(ruby, r_hash::RHash::try_convert(value)?)?.into())
@@ -152,6 +167,7 @@ fn to_rvalue(ruby: &Ruby, val: gqlitedb::Value) -> Result<magnus::Value, Error>
     gqlitedb::Value::Integer(i) => Ok(i.into_value_with(ruby)),
     gqlitedb::Value::Float(f) => Ok(f.into_value_with(ruby)),
     gqlitedb::Value::String(s) => Ok(s.into_value_with(ruby)),
+    gqlitedb::Value::TimeStamp(s) => Ok(to_rdatetime(ruby, s)?.into_value_with(ruby)),
     gqlitedb::Value::Map(m) => Ok(to_rhash(ruby, m)?.into_value_with(ruby)),
     gqlitedb::Value::Null => Ok(ruby.qnil().into_value_with(ruby)),
     gqlitedb::Value::Edge(e) => Ok(edge_to_rhash(ruby, e)?),
@@ -160,6 +176,18 @@ fn to_rvalue(ruby: &Ruby, val: gqlitedb::Value) -> Result<magnus::Value, Error>
   }
 }
 
+fn to_rdatetime(ruby: &Ruby, ts: gqlitedb::TimeStamp) -> Result<magnus::Time, Error>
+{
+  let (tv_sec, tv_nsec) = ts.unix_timestamp();
+  ruby.time_timespec_new(
+    magnus::time::Timespec {
+      tv_sec,
+      tv_nsec: tv_nsec as i64,
+    },
+    map_err(ruby, magnus::time::Offset::from_secs(ts.offset_seconds()))?,
+  )
+}
+
 fn to_rhash(ruby: &Ruby, map: gqlitedb::ValueMap) -> Result<r_hash::RHash, Error>
 {
   let r_hash = ruby.hash_new();

data/ext/graphcore/Cargo.toml

@@ -1,16 +1,17 @@
 [package]
 name = "graphcore"
 description = "Base data structure to represent and manipulate property graph."
-# version.workspace = true
-version = "0.2.0"
 readme = "README.MD"
+version.workspace = true
 edition.workspace = true
 license.workspace = true
 homepage.workspace = true
 repository.workspace = true
 
 [dependencies]
+ccutils = { workspace = true, features = ["alias"] }
 itertools = { workspace = true }
+jiff = { version = "0.2" }
 serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }
 uuid = { workspace = true }

data/ext/graphcore/src/error.rs

@@ -25,4 +25,6 @@ pub enum Error
   InvalidTableDimensions,
   #[error("Out of range access.")]
   InvalidRange,
+  #[error("TimeStamp error {0}.")]
+  TimeError(#[from] jiff::Error),
 }

data/ext/graphcore/src/lib.rs

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

data/ext/graphcore/src/prelude.rs

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

data/ext/graphcore/src/table.rs

@@ -15,7 +15,7 @@ impl Table
   /// 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
+    if !data.len().is_multiple_of(headers.len())
     {
       Err(error::Error::InvalidTableDimensions)?;
     }

data/ext/graphcore/src/timestamp.rs

@@ -0,0 +1,104 @@
+use std::fmt;
+
+use jiff::{tz::TimeZone, Zoned};
+use serde::{Deserialize, Serialize};
+
+ccutils::alias!(#[doc = "Represent a timestamp"] pub TimeStamp, Zoned, display, derive: Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord);
+
+impl TimeStamp
+{
+  /// Create a new time stamp with the given unix timestamp and  offset
+  pub fn from_unix_timestamp(
+    seconds: i64,
+    nanoseconds: i32,
+    offset_whole_seconds: i32,
+  ) -> Result<TimeStamp, crate::Error>
+  {
+    let ts = jiff::Timestamp::new(seconds, nanoseconds)?;
+    Ok(Self(ts.to_zoned(jiff::tz::TimeZone::fixed(
+      jiff::tz::Offset::from_seconds(offset_whole_seconds)?,
+    ))))
+  }
+
+  /// Convert from the current time zone to Utc (aka offset == 0)
+  pub fn to_utc(&self) -> TimeStamp
+  {
+    Self(self.with_time_zone(TimeZone::UTC))
+  }
+  /// Return the unix timestamp
+  pub fn unix_timestamp(&self) -> (i64, i32)
+  {
+    let ts = self.0.timestamp();
+    (ts.as_second(), ts.subsec_nanosecond())
+  }
+  /// Return the number of whole seconds in the offset
+  pub fn offset_seconds(&self) -> i32
+  {
+    self.0.offset().seconds()
+  }
+  /// Return the year in the timestamp timezone
+  pub fn year(&self) -> i16
+  {
+    self.0.year()
+  }
+  /// Return the month in the timestamp timezone
+  pub fn month(&self) -> i8
+  {
+    self.0.month()
+  }
+  /// Return the day in the timestamp timezone
+  pub fn day(&self) -> i8
+  {
+    self.0.day()
+  }
+  /// Return the hour in the timestamp timezone
+  pub fn hour(&self) -> i8
+  {
+    self.0.hour()
+  }
+  /// Return the minute in the timestamp timezone
+  pub fn minute(&self) -> i8
+  {
+    self.0.minute()
+  }
+  /// Return the second in the timestamp timezone
+  pub fn second(&self) -> i8
+  {
+    self.0.second()
+  }
+  /// Return the microseconds in the timestamp timezone
+  pub fn microsecond(&self) -> i16
+  {
+    self.0.microsecond()
+  }
+  /// Parse the time string
+  pub fn parse(date: &str) -> Result<TimeStamp, crate::Error>
+  {
+    Ok(TimeStamp(date.parse()?))
+  }
+}
+
+// Serde impl
+
+impl Serialize for TimeStamp
+{
+  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+  where
+    S: serde::Serializer,
+  {
+    self.0.to_string().serialize(serializer)
+  }
+}
+
+impl<'de> Deserialize<'de> for TimeStamp
+{
+  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+  where
+    D: serde::Deserializer<'de>,
+  {
+    use serde::de::Error;
+    let s = String::deserialize(deserializer)?;
+    TimeStamp::parse(&s)
+      .map_err(|e| D::Error::custom(format!("Error deserializing timestamp: {}.", e)))
+  }
+}