gqlite 1.2.2 → 1.3.0

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

@@ -112,30 +112,35 @@ pub(crate) trait Store
   fn create_graph(
     &self,
     transaction: &mut Self::TransactionBox,
-    name: &String,
-    _ignore_if_exists: bool,
+    name: impl AsRef<str>,
+    ignore_if_exists: bool,
   ) -> Result<()>;
   /// Delete a graph
-  fn delete_graph(&self, transaction: &mut Self::TransactionBox, name: &String) -> Result<()>;
+  fn drop_graph(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    name: impl AsRef<str>,
+    if_exists: bool,
+  ) -> Result<()>;
   /// Create nodes and add them to a graph
-  fn create_nodes<'a, T: Iterator<Item = &'a crate::graph::Node>>(
+  fn create_nodes<'a, T: IntoIterator<Item = &'a crate::graph::Node>>(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     nodes_iter: T,
   ) -> Result<()>;
   /// Create nodes and add them to a graph
   fn update_node(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     node: &graph::Node,
   ) -> Result<()>;
   /// Delete nodes according to a given query
   fn delete_nodes(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     query: SelectNodeQuery,
     detach: bool,
   ) -> Result<()>;
@@ -143,27 +148,27 @@ pub(crate) trait Store
   fn select_nodes(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     query: SelectNodeQuery,
   ) -> Result<Vec<crate::graph::Node>>;
   /// Add edge
-  fn create_edges<'a, T: Iterator<Item = &'a crate::graph::Edge>>(
+  fn create_edges<'a, T: IntoIterator<Item = &'a crate::graph::SinglePath>>(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     edges_iter: T,
   ) -> Result<()>;
   fn update_edge(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     edge: &graph::Edge,
   ) -> Result<()>;
   /// Delete nodes according to a given query
   fn delete_edges(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     query: SelectEdgeQuery,
     directivity: graph::EdgeDirectivity,
   ) -> Result<()>;
@@ -171,7 +176,7 @@ pub(crate) trait Store
   fn select_edges(
     &self,
     transaction: &mut Self::TransactionBox,
-    graph_name: &String,
+    graph_name: impl AsRef<str>,
     query: SelectEdgeQuery,
     directivity: graph::EdgeDirectivity,
   ) -> Result<Vec<EdgeResult>>;
@@ -188,7 +193,7 @@ pub(crate) trait Store
 
 pub(crate) struct EdgeResult
 {
-  pub(crate) edge: graph::Edge,
+  pub(crate) path: graph::SinglePath,
   pub(crate) reversed: bool,
 }
 
@@ -250,6 +255,7 @@ impl SelectNodeQuery
       select_all: false,
     }
   }
+  #[allow(dead_code)]
   pub(crate) fn select_labels(labels: impl Into<Vec<String>>) -> Self
   {
     Self {
@@ -279,14 +285,14 @@ impl SelectNodeQuery
     }
     if let Some(keys) = &self.keys
     {
-      if !keys.iter().any(|x| node.key == *x)
+      if !keys.iter().any(|x| node.key() == *x)
       {
         return false;
       }
     }
     if let Some(labels) = &self.labels
     {
-      if !labels.iter().all(|x| node.labels.contains(x))
+      if !labels.iter().all(|x| node.labels().contains(x))
       {
         return false;
       }
@@ -295,12 +301,12 @@ impl SelectNodeQuery
     {
       if !properties
         .iter()
-        .all(|(k, v)| node.properties.get(k) == Some(v))
+        .all(|(k, v)| node.properties().get(k) == Some(v))
       {
         return false;
       }
     }
-    return true;
+    true
   }
 }
 
@@ -323,6 +329,7 @@ pub(crate) struct SelectEdgeQuery
 
 impl SelectEdgeQuery
 {
+  #[allow(dead_code)]
   pub(crate) fn is_select_only_keys(&self) -> bool
   {
     self.keys.is_some()
@@ -402,18 +409,18 @@ impl SelectEdgeQuery
       destination: destination_query,
     }
   }
-  pub(crate) fn is_match(&self, edge: &graph::Edge) -> bool
+  pub(crate) fn is_match(&self, edge: &graph::Path) -> bool
   {
     if let Some(keys) = &self.keys
     {
-      if !keys.iter().any(|x| edge.key == *x)
+      if !keys.iter().any(|x| edge.key() == *x)
       {
         return false;
       }
     }
     if let Some(labels) = &self.labels
     {
-      if !labels.iter().all(|x| edge.labels.contains(x))
+      if !labels.iter().all(|x| edge.labels().contains(x))
       {
         return false;
       }
@@ -422,11 +429,11 @@ impl SelectEdgeQuery
     {
       if !properties
         .iter()
-        .all(|(k, v)| edge.properties.get(k) == Some(v))
+        .all(|(k, v)| edge.properties().get(k) == Some(v))
       {
         return false;
       }
     }
-    return self.source.is_match(&edge.source) && self.destination.is_match(&edge.destination);
+    self.source.is_match(edge.source()) && self.destination.is_match(edge.destination())
   }
 }

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/tests/evaluators.rs

@@ -9,7 +9,7 @@ use crate::{
 fn test_evaluate_simple_create_node()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::redb::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
 
   eval_program(&store, &programs::simple_create(), &Default::default()).unwrap();
   check_stats(&store, None, 1, 0, 0, 0);
@@ -19,22 +19,19 @@ fn test_evaluate_simple_create_node()
 fn test_evaluate_create_named_node()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::redb::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
 
   let value = eval_program(&store, &programs::create_named_node(), &Default::default()).unwrap();
   check_stats(&store, None, 1, 0, 0, 1);
 
-  assert_eq!(
-    value,
-    value::array![value::array!["p"], value::array!["foo"]]
-  );
+  assert_eq!(value, graphcore::table![("p"), [["foo"]]].into());
 }
 
 #[test]
 fn test_evaluate_create_named_node_double_return()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::redb::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
 
   let value = eval_program(
     &store,
@@ -44,47 +41,40 @@ fn test_evaluate_create_named_node_double_return()
   .unwrap();
   check_stats(&store, None, 1, 0, 0, 2);
 
-  assert_eq!(
-    value,
-    value::array![value::array!["id", "p"], value::array![12, "foo"]]
-  );
+  assert_eq!(value, graphcore::table![("id", "p"), [[12, "foo"]]].into());
 }
 
 #[test]
 fn test_evaluate_double_with_return()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::redb::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
 
   let value = eval_program(&store, &programs::double_with_return(), &Default::default()).unwrap();
   check_stats(&store, None, 0, 0, 0, 0);
 
-  assert_eq!(value, value::array![value::array!["a"], value::array![1]]);
+  assert_eq!(value, crate::table![("a"), [[1,]]].into());
 }
 
 #[test]
 fn test_evaluate_unwind()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::redb::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
 
   let value = eval_program(&store, &programs::unwind(), &Default::default()).unwrap();
   check_stats(&store, None, 0, 0, 0, 0);
 
-  assert_eq!(value, value::array![value::array!["i"], value::array![0]]);
+  assert_eq!(value, crate::table![("i"), [[0,]]].into());
 }
 
 #[test]
 fn test_evaluate_match_loop()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::redb::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
 
-  let node = graph::Node {
-    key: graph::Key { uuid: 1 },
-    labels: vec![],
-    properties: Default::default(),
-  };
+  let node = graph::Node::new(graph::Key::new(1), vec![], Default::default());
   let mut tx = store.begin_write().unwrap();
   store
     .create_nodes(&mut tx, &"default".to_string(), vec![&node].into_iter())
@@ -93,13 +83,13 @@ fn test_evaluate_match_loop()
     .create_edges(
       &mut tx,
       &"default".to_string(),
-      vec![&graph::Edge {
-        key: graph::Key { uuid: 2 },
-        source: node.clone(),
-        destination: node.clone(),
-        labels: vec![],
-        properties: Default::default(),
-      }]
+      vec![&graph::Path::new(
+        graph::Key::new(2),
+        node.clone(),
+        vec![],
+        Default::default(),
+        node.clone(),
+      )]
       .into_iter(),
     )
     .unwrap();
@@ -108,32 +98,26 @@ fn test_evaluate_match_loop()
   let value = eval_program(&store, &programs::match_loop(), &Default::default()).unwrap();
   check_stats(&store, None, 1, 1, 0, 0);
 
-  assert_eq!(
-    value,
-    value::array![value::array!["n"], value::array![node]]
-  );
+  assert_eq!(value, crate::table![("n"), [[node]]].into());
 }
 
 #[test]
 fn test_evaluate_optional_match()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::redb::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
 
   let value = eval_program(&store, &programs::optional_match(), &Default::default()).unwrap();
   check_stats(&store, None, 0, 0, 0, 0);
 
-  assert_eq!(
-    value,
-    value::array![value::array!["a"], value::array![value::Value::Null]]
-  );
+  assert_eq!(value, crate::table![("a"), [[value::Value::Null]]].into());
 }
 
 #[test]
 fn test_evaluate_match_count()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::redb::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
   let function_manager = functions::Manager::new();
   let program = programs::match_count(&function_manager);
 
@@ -141,17 +125,10 @@ fn test_evaluate_match_count()
   let value = eval_program(&store, &program, &Default::default()).unwrap();
   check_stats(&store, None, 0, 0, 0, 0);
 
-  assert_eq!(
-    value,
-    value::array![value::array!["count(*)"], value::array![0]]
-  );
+  assert_eq!(value, crate::table![("count(*)"), [[0]]].into());
 
   // Count 1
-  let node = graph::Node {
-    key: graph::Key { uuid: 1 },
-    labels: vec![],
-    properties: Default::default(),
-  };
+  let node = graph::Node::new(graph::Key::new(1), vec![], Default::default());
   let mut tx = store.begin_write().unwrap();
   store
     .create_nodes(&mut tx, &"default".to_string(), vec![&node].into_iter())
@@ -162,36 +139,29 @@ fn test_evaluate_match_count()
   let value = eval_program(&store, &program, &Default::default()).unwrap();
   check_stats(&store, None, 1, 0, 0, 0);
 
-  assert_eq!(
-    value,
-    value::array![value::array!["count(*)"], value::array![1]]
-  );
+  assert_eq!(value, crate::table![("count(*)"), [[1]]].into());
 }
 
 #[test]
 fn test_evaluate_aggregation()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::redb::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
   let function_manager = functions::Manager::new();
   let program = programs::aggregation(&function_manager);
 
   let nodes = vec![
-    graph::Node {
-      key: graph::Key { uuid: 1 },
-      labels: vec![],
-      properties: value::map!("name" => "a", "num" => 33),
-    },
-    graph::Node {
-      key: graph::Key { uuid: 2 },
-      labels: vec![],
-      properties: value::map!("name" => "a"),
-    },
-    graph::Node {
-      key: graph::Key { uuid: 3 },
-      labels: vec![],
-      properties: value::map!("name" => "b", "num" => 42),
-    },
+    graph::Node::new(
+      graph::Key::new(1),
+      vec![],
+      value::value_map!("name" => "a", "num" => 33),
+    ),
+    graph::Node::new(graph::Key::new(2), vec![], value::value_map!("name" => "a")),
+    graph::Node::new(
+      graph::Key::new(3),
+      vec![],
+      value::value_map!("name" => "b", "num" => 42),
+    ),
   ];
   let mut tx = store.begin_write().unwrap();
   store
@@ -204,24 +174,10 @@ fn test_evaluate_aggregation()
   check_stats(&store, None, 3, 0, 0, 5);
 
   assert!(
-    value
-      == value::array![
-        value::array!["n.name", "count(n.num)"],
-        value::array!["a", 1],
-        value::array!["b", 1]
-      ]
-      || value
-        == value::array![
-          value::array!["n.name", "count(n.num)"],
-          value::array!["b", 1],
-          value::array!["a", 1]
-        ],
-    "left ({}) == right ({} in any order) failed",
+    value == crate::table![("n.name", "count(n.num)"), [["a", 1], ["b", 1]]].into()
+      || value == crate::table![("n.name", "count(n.num)"), [["b", 1], ["a", 1]]].into(),
+    "left ({}) == right ({:?} in any order) failed",
     value,
-    value::array![
-      value::array!["n.name", "count(n.num)"],
-      value::array!["a", 1],
-      value::array!["b", 1]
-    ],
+    crate::table![("n.name", "count(n.num)"), [["a", 1], ["b", 1]]],
   );
 }

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/tests/store/redb.rs

@@ -1,8 +1,15 @@
+#[test]
+fn test_in_memory()
+{
+  let store = crate::store::redb::Store::in_memory().unwrap();
+  super::test_select_nodes(store);
+}
+
 #[test]
 fn test_graphs()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::redb::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
   super::test_graphs(store);
 }
 
@@ -10,7 +17,7 @@ fn test_graphs()
 fn test_select_nodes()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::redb::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
   super::test_select_nodes(store);
 }
 
@@ -18,7 +25,7 @@ fn test_select_nodes()
 fn test_update_nodes()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::redb::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
   super::test_update_nodes(store);
 }
 
@@ -26,7 +33,7 @@ fn test_update_nodes()
 fn test_select_edges()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::redb::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
   super::test_select_edges(store);
 }
 
@@ -34,6 +41,6 @@ fn test_select_edges()
 fn test_update_edges()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::redb::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
   super::test_update_edges(store);
 }

data/ext/{gqliterb/vendor/gqlitedb → gqlitedb}/src/tests/store/sqlite.rs

@@ -1,8 +1,15 @@
+#[test]
+fn test_in_memory()
+{
+  let store = crate::store::sqlite::Store::in_memory().unwrap();
+  super::test_select_nodes(store);
+}
+
 #[test]
 fn test_graphs()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::redb::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::sqlite::Store::open(temp_file.path()).unwrap();
   super::test_graphs(store);
 }
 
@@ -10,7 +17,7 @@ fn test_graphs()
 fn test_select_nodes()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::sqlite::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::sqlite::Store::open(temp_file.path()).unwrap();
   super::test_select_nodes(store);
 }
 
@@ -18,7 +25,7 @@ fn test_select_nodes()
 fn test_update_nodes()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::sqlite::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::sqlite::Store::open(temp_file.path()).unwrap();
   super::test_update_nodes(store);
 }
 
@@ -26,7 +33,7 @@ fn test_update_nodes()
 fn test_select_edges()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::sqlite::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::sqlite::Store::open(temp_file.path()).unwrap();
   super::test_select_edges(store);
 }
 
@@ -34,6 +41,6 @@ fn test_select_edges()
 fn test_update_edges()
 {
   let temp_file = crate::tests::create_tmp_file();
-  let store = crate::store::sqlite::Store::new(temp_file.path()).unwrap();
+  let store = crate::store::sqlite::Store::open(temp_file.path()).unwrap();
   super::test_update_edges(store);
 }