gqlite 1.2.3 → 1.3.0

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

@@ -112,35 +112,35 @@ pub(crate) trait Store
   fn create_graph(
     &self,
     transaction: &mut Self::TransactionBox,
-    name: &String,
+    name: impl AsRef<str>,
     ignore_if_exists: bool,
   ) -> Result<()>;
   /// Delete a graph
   fn drop_graph(
     &self,
     transaction: &mut Self::TransactionBox,
-    name: &String,
+    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<()>;
@@ -148,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<()>;
@@ -176,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>>;
@@ -193,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,
 }
 
@@ -285,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;
       }
@@ -301,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
   }
 }
 
@@ -409,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;
       }
@@ -429,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

@@ -24,10 +24,7 @@ fn test_evaluate_create_named_node()
   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]
@@ -44,10 +41,7 @@ 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]
@@ -59,7 +53,7 @@ fn test_evaluate_double_with_return()
   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]
@@ -71,7 +65,7 @@ fn test_evaluate_unwind()
   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]
@@ -80,11 +74,7 @@ fn test_evaluate_match_loop()
   let temp_file = crate::tests::create_tmp_file();
   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,10 +98,7 @@ 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]
@@ -123,10 +110,7 @@ fn test_evaluate_optional_match()
   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]
@@ -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,10 +139,7 @@ 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]
@@ -177,21 +151,17 @@ fn test_evaluate_aggregation()
   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]]],
   );
 }