gqlite 1.2.2 → 1.3.0

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

@@ -53,10 +53,10 @@ where
     vec!["default".to_string(), "test_graph".to_string()]
   );
 
-  // Delete graph
+  // Drop graph
   let mut tx = store.begin_write().unwrap();
   store
-    .delete_graph(&mut tx, &"test_graph".to_string())
+    .drop_graph(&mut tx, &"test_graph".to_string(), false)
     .unwrap();
   tx.close().unwrap();
 
@@ -81,11 +81,19 @@ where
     vec!["default".to_string(), "test_graph".to_string()]
   );
 
+  // Drop unexisting graph
   let mut tx = store.begin_write().unwrap();
   store
-    .delete_graph(&mut tx, &"unknown".to_string())
+    .drop_graph(&mut tx, &"unknown".to_string(), false)
     .expect_err("Attempt at deleting unknown graph.");
   drop(tx);
+
+  // Drop unexisting graph
+  let mut tx = store.begin_write().unwrap();
+  store
+    .drop_graph(&mut tx, &"unknown".to_string(), true)
+    .unwrap();
+  drop(tx);
 }
 
 fn test_select_nodes<TStore>(store: TStore)
@@ -94,16 +102,16 @@ where
 {
   // Add two nodes
   let nodes = [
-    graph::Node {
-      labels: graph::labels!("hello", "world"),
-      properties: value::map!("key" => 42i64),
-      key: graph::Key::default(),
-    },
-    graph::Node {
-      labels: graph::labels!("not"),
-      properties: Default::default(),
-      key: graph::Key::default(),
-    },
+    graph::Node::new(
+      graph::Key::default(),
+      graph::labels!("hello", "world"),
+      value::value_map!("key" => 42i64),
+    ),
+    graph::Node::new(
+      graph::Key::default(),
+      graph::labels!("not"),
+      Default::default(),
+    ),
   ];
 
   check_stats(&store, None, 0, 0, 0, 0);
@@ -111,7 +119,7 @@ where
   let mut tx = store.begin_write().unwrap();
 
   store
-    .create_nodes(tx.borrow_mut(), &"default".into(), nodes.iter())
+    .create_nodes(tx.borrow_mut(), "default", nodes.iter())
     .unwrap();
   tx.close().unwrap();
   check_stats(&store, None, 2, 0, 3, 1);
@@ -119,8 +127,8 @@ where
   let selected_nodes = store
     .select_nodes(
       store.begin_read().unwrap().borrow_mut(),
-      &"default".into(),
-      store::SelectNodeQuery::select_keys([nodes[0].key]),
+      "default",
+      store::SelectNodeQuery::select_keys([nodes[0].key()]),
     )
     .unwrap();
 
@@ -130,7 +138,7 @@ where
   let selected_nodes = store
     .select_nodes(
       store.begin_read().unwrap().borrow_mut(),
-      &"default".into(),
+      "default",
       store::SelectNodeQuery::select_labels(["not".to_string()]),
     )
     .unwrap();
@@ -144,32 +152,28 @@ where
   TStore: store::Store,
 {
   // Add a node
-  let node = graph::Node {
-    labels: graph::labels!("hello", "world"),
-    properties: value::map!("key" => 42i64),
-    key: graph::Key::default(),
-  };
+  let node = graph::Node::new(
+    graph::Key::default(),
+    graph::labels!("hello", "world"),
+    value::value_map!("key" => 42i64),
+  );
 
   check_stats(&store, None, 0, 0, 0, 0);
 
   let mut tx = store.begin_write().unwrap();
 
   store
-    .create_nodes(
-      tx.borrow_mut(),
-      &"default".into(),
-      vec![node.clone()].iter(),
-    )
+    .create_nodes(tx.borrow_mut(), "default", vec![node.clone()].iter())
     .unwrap();
   tx.close().unwrap();
   check_stats(&store, None, 1, 0, 2, 1);
 
   // Modify node
-  let modified_node = graph::Node {
-    labels: graph::labels!("world"),
-    properties: value::map!("key" => 12i64),
-    key: node.key.clone(),
-  };
+  let modified_node = graph::Node::new(
+    node.key().clone(),
+    graph::labels!("world"),
+    value::value_map!("key" => 12i64),
+  );
 
   let mut tx = store.begin_write().unwrap();
   store
@@ -181,7 +185,7 @@ where
   let selected_nodes = store
     .select_nodes(
       store.begin_read().unwrap().borrow_mut(),
-      &"default".into(),
+      "default",
       store::SelectNodeQuery::select_all(),
     )
     .unwrap();
@@ -193,8 +197,8 @@ where
   store
     .delete_nodes(
       &mut tx,
-      &"default".into(),
-      store::SelectNodeQuery::select_keys([modified_node.key]),
+      "default",
+      store::SelectNodeQuery::select_keys([modified_node.key()]),
       true,
     )
     .unwrap();
@@ -207,40 +211,40 @@ fn test_select_edges<TStore>(store: TStore)
 where
   TStore: store::Store,
 {
-  let source_node = graph::Node {
-    labels: graph::labels!("hello"),
-    properties: value::map!("key" => 42i64),
-    key: graph::Key::default(),
-  };
-  let destination_node = graph::Node {
-    labels: graph::labels!("world"),
-    properties: value::map!("key" => 12i64),
-    key: graph::Key::default(),
-  };
-  let edge = graph::Edge {
-    source: source_node.clone(),
-    destination: destination_node.clone(),
-    key: graph::Key::default(),
-    labels: vec!["!".into()],
-    properties: value::map!("existence" => true),
-  };
+  let source_node = graph::Node::new(
+    graph::Key::default(),
+    graph::labels!("hello"),
+    value::value_map!("key" => 42i64),
+  );
+  let destination_node = graph::Node::new(
+    graph::Key::default(),
+    graph::labels!("world"),
+    value::value_map!("key" => 12i64),
+  );
+  let edge = graph::SinglePath::new(
+    graph::Key::default(),
+    source_node.clone(),
+    vec!["!".into()],
+    value::value_map!("existence" => true),
+    destination_node.clone(),
+  );
 
   check_stats(&store, None, 0, 0, 0, 0);
 
   let mut tx = store.begin_write().unwrap();
   store
-    .create_edges(tx.borrow_mut(), &"default".into(), [edge.clone()].iter())
+    .create_edges(tx.borrow_mut(), "default", [edge.clone()].iter())
     .expect_err("expect missing node");
   check_stats(&store, Some(&mut tx), 0, 0, 0, 0);
   store
     .create_nodes(
       tx.borrow_mut(),
-      &"default".into(),
+      "default",
       [source_node, destination_node].iter(),
     )
     .unwrap();
   store
-    .create_edges(tx.borrow_mut(), &"default".into(), [edge.clone()].iter())
+    .create_edges(tx.borrow_mut(), "default", [edge.clone()].iter())
     .unwrap();
   tx.close().unwrap();
   check_stats(&store, None, 2, 1, 2, 3);
@@ -248,20 +252,20 @@ where
   let selected_edges = store
     .select_edges(
       store.begin_read().unwrap().borrow_mut(),
-      &"default".into(),
-      store::SelectEdgeQuery::select_keys([edge.key]),
+      "default",
+      store::SelectEdgeQuery::select_keys([edge.key()]),
       graph::EdgeDirectivity::Directed,
     )
     .unwrap();
 
   assert_eq!(1, selected_edges.len());
-  assert_eq!(edge, selected_edges[0].edge);
+  assert_eq!(edge, selected_edges[0].path);
   assert!(!selected_edges[0].reversed);
 
   let selected_edges = store
     .select_edges(
       store.begin_read().unwrap().borrow_mut(),
-      &"default".into(),
+      "default",
       store::SelectEdgeQuery::select_source_destination_labels_properties(
         store::SelectNodeQuery::select_all(),
         vec![],
@@ -273,13 +277,13 @@ where
     .unwrap();
 
   assert_eq!(1, selected_edges.len());
-  assert_eq!(edge, selected_edges[0].edge);
+  assert_eq!(edge, selected_edges[0].path);
   assert!(!selected_edges[0].reversed);
 
   let selected_edges = store
     .select_edges(
       store.begin_read().unwrap().borrow_mut(),
-      &"default".into(),
+      "default",
       store::SelectEdgeQuery::select_source_destination_labels_properties(
         store::SelectNodeQuery::select_labels_properties(vec![], Default::default()),
         vec![],
@@ -291,19 +295,19 @@ where
     .unwrap();
 
   assert_eq!(1, selected_edges.len());
-  assert_eq!(edge, selected_edges[0].edge);
+  assert_eq!(edge, selected_edges[0].path);
   assert!(!selected_edges[0].reversed);
 
   // Check reverse direction
   let selected_edges = store
     .select_edges(
       store.begin_read().unwrap().borrow_mut(),
-      &"default".into(),
+      "default",
       store::SelectEdgeQuery::select_source_destination_labels_properties(
-        store::SelectNodeQuery::select_keys(vec![edge.destination.key]),
+        store::SelectNodeQuery::select_keys(vec![edge.destination().key()]),
         vec![],
         Default::default(),
-        store::SelectNodeQuery::select_keys(vec![edge.source.key]),
+        store::SelectNodeQuery::select_keys(vec![edge.source().key()]),
       ),
       graph::EdgeDirectivity::Directed,
     )
@@ -314,19 +318,19 @@ where
   let selected_edges = store
     .select_edges(
       store.begin_read().unwrap().borrow_mut(),
-      &"default".into(),
+      "default",
       store::SelectEdgeQuery::select_source_destination_labels_properties(
-        store::SelectNodeQuery::select_keys(vec![edge.destination.key]),
+        store::SelectNodeQuery::select_keys(vec![edge.destination().key()]),
         vec![],
         Default::default(),
-        store::SelectNodeQuery::select_keys(vec![edge.source.key]),
+        store::SelectNodeQuery::select_keys(vec![edge.source().key()]),
       ),
       graph::EdgeDirectivity::Undirected,
     )
     .unwrap();
 
   assert_eq!(1, selected_edges.len());
-  assert_eq!(edge, selected_edges[0].edge);
+  assert_eq!(edge, selected_edges[0].path);
   assert!(selected_edges[0].reversed);
 }
 
@@ -334,65 +338,63 @@ fn test_update_edges<TStore>(store: TStore)
 where
   TStore: store::Store,
 {
-  let source_node = graph::Node {
-    labels: graph::labels!("hello"),
-    properties: value::map!("key" => 42i64),
-    key: graph::Key::default(),
-  };
-  let destination_node = graph::Node {
-    labels: graph::labels!("world"),
-    properties: value::map!("key" => 12i64),
-    key: graph::Key::default(),
-  };
-  let edge = graph::Edge {
-    source: source_node.clone(),
-    destination: destination_node.clone(),
-    key: graph::Key::default(),
-    labels: vec!["!".into()],
-    properties: value::map!("existence" => true),
-  };
+  let source_node = graph::Node::new(
+    graph::Key::default(),
+    graph::labels!("hello"),
+    value::value_map!("key" => 42i64),
+  );
+  let destination_node = graph::Node::new(
+    graph::Key::default(),
+    graph::labels!("world"),
+    value::value_map!("key" => 12i64),
+  );
+  let edge = graph::SinglePath::new(
+    graph::Key::default(),
+    source_node.clone(),
+    vec!["!".into()],
+    value::value_map!("existence" => true),
+    destination_node.clone(),
+  );
 
   check_stats(&store, None, 0, 0, 0, 0);
 
   // Insert edge in store
   let mut tx = store.begin_write().unwrap();
   store
-    .create_edges(tx.borrow_mut(), &"default".into(), [edge.clone()].iter())
+    .create_edges(tx.borrow_mut(), "default", [edge.clone()].iter())
     .expect_err("expect missing node");
   check_stats(&store, Some(&mut tx), 0, 0, 0, 0);
   store
     .create_nodes(
       tx.borrow_mut(),
-      &"default".into(),
+      "default",
       [source_node, destination_node].iter(),
     )
     .unwrap();
   store
-    .create_edges(tx.borrow_mut(), &"default".into(), [edge.clone()].iter())
+    .create_edges(tx.borrow_mut(), "default", [edge.clone()].iter())
     .unwrap();
   tx.close().unwrap();
   check_stats(&store, None, 2, 1, 2, 3);
 
   // Modify edge
 
-  let modified_edge = graph::Edge {
-    key: edge.key.clone(),
-    source: edge.source.clone(),
-    destination: edge.destination.clone(),
-    labels: vec!["?".into()],
-    properties: value::map!("existence" => false),
-  };
+  let modified_edge = graph::Edge::new(
+    edge.key().clone(),
+    graph::labels!("?"),
+    value::value_map!("existence" => false),
+  );
 
   let mut tx = store.begin_write().unwrap();
   store
-    .update_edge(&mut tx, &"default".into(), &modified_edge)
+    .update_edge(&mut tx, "default", &modified_edge)
     .unwrap();
   tx.close().unwrap();
 
   let selected_edges = store
     .select_edges(
       store.begin_read().unwrap().borrow_mut(),
-      &"default".into(),
+      "default",
       store::SelectEdgeQuery::select_all(),
       graph::EdgeDirectivity::Directed,
     )
@@ -401,7 +403,7 @@ where
   check_stats(&store, None, 2, 1, 2, 3);
 
   assert_eq!(1, selected_edges.len());
-  assert_eq!(modified_edge, selected_edges[0].edge);
+  assert_eq!(modified_edge, selected_edges[0].path.to_owned().into());
   assert!(!selected_edges[0].reversed);
 
   // Remove edge
@@ -410,7 +412,7 @@ where
   store
     .delete_edges(
       &mut tx,
-      &"default".into(),
+      "default",
       store::SelectEdgeQuery::select_all(),
       graph::EdgeDirectivity::Directed,
     )
@@ -421,7 +423,7 @@ where
   let selected_edges = store
     .select_edges(
       store.begin_read().unwrap().borrow_mut(),
-      &"default".into(),
+      "default",
       store::SelectEdgeQuery::select_all(),
       graph::EdgeDirectivity::Directed,
     )
@@ -432,30 +434,20 @@ where
   // Add edge back, and remove one of the node
   let mut tx = store.begin_write().unwrap();
   store
-    .create_edges(tx.borrow_mut(), &"default".into(), [edge.clone()].iter())
+    .create_edges(tx.borrow_mut(), "default", [edge.clone()].iter())
     .unwrap();
   tx.close().unwrap();
   check_stats(&store, None, 2, 1, 2, 3);
 
   let mut tx = store.begin_write().unwrap();
   store
-    .delete_nodes(
-      &mut tx,
-      &"default".into(),
-      SelectNodeQuery::select_all(),
-      false,
-    )
+    .delete_nodes(&mut tx, "default", SelectNodeQuery::select_all(), false)
     .expect_err("should fails, nodes are still connected.");
   tx.close().unwrap();
 
   let mut tx = store.begin_write().unwrap();
   store
-    .delete_nodes(
-      &mut tx,
-      &"default".into(),
-      SelectNodeQuery::select_all(),
-      true,
-    )
+    .delete_nodes(&mut tx, "default", SelectNodeQuery::select_all(), true)
     .unwrap();
   tx.close().unwrap();
   check_stats(&store, None, 0, 0, 0, 0);

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

@@ -37,7 +37,7 @@ pub(crate) fn create_named_node() -> Statements
   vec![
     Create {
       patterns: vec![Pattern::Node(NodePattern {
-        variable: Some(var_ids.from_name("n")),
+        variable: Some(var_ids.create_variable_from_name("n")),
         labels: LabelExpression::None,
         properties: Some(
           Map {
@@ -57,10 +57,10 @@ pub(crate) fn create_named_node() -> Statements
     Return {
       all: false,
       expressions: vec![NamedExpression {
-        identifier: var_ids.from_name("p"),
+        identifier: var_ids.create_variable_from_name("p"),
         expression: MemberAccess {
           left: Variable {
-            identifier: var_ids.from_name("n"),
+            identifier: var_ids.create_variable_from_name("n"),
           }
           .into(),
           path: vec!["name".into()],
@@ -85,7 +85,7 @@ pub(crate) fn create_named_node_double_return() -> Statements
   vec![
     Create {
       patterns: vec![Pattern::Node(NodePattern {
-        variable: Some(var_ids.from_name("n")),
+        variable: Some(var_ids.create_variable_from_name("n")),
         labels: LabelExpression::None,
         properties: Some(
           Map {
@@ -109,10 +109,10 @@ pub(crate) fn create_named_node_double_return() -> Statements
       all: false,
       expressions: vec![
         NamedExpression {
-          identifier: var_ids.from_name("id"),
+          identifier: var_ids.create_variable_from_name("id"),
           expression: MemberAccess {
             left: Variable {
-              identifier: var_ids.from_name("n"),
+              identifier: var_ids.create_variable_from_name("n"),
             }
             .into(),
             path: vec!["id".into()],
@@ -120,10 +120,10 @@ pub(crate) fn create_named_node_double_return() -> Statements
           .into(),
         },
         NamedExpression {
-          identifier: var_ids.from_name("p"),
+          identifier: var_ids.create_variable_from_name("p"),
           expression: MemberAccess {
             left: Variable {
-              identifier: var_ids.from_name("n"),
+              identifier: var_ids.create_variable_from_name("n"),
             }
             .into(),
             path: vec!["name".into()],
@@ -151,11 +151,11 @@ pub(crate) fn double_with_return() -> Statements
       all: false,
       expressions: vec![
         NamedExpression {
-          identifier: var_ids.from_name("n"),
+          identifier: var_ids.create_variable_from_name("n"),
           expression: Value { value: 1.into() }.into(),
         },
         NamedExpression {
-          identifier: var_ids.from_name("m"),
+          identifier: var_ids.create_variable_from_name("m"),
           expression: Value { value: 2.into() }.into(),
         },
       ],
@@ -171,16 +171,16 @@ pub(crate) fn double_with_return() -> Statements
       all: false,
       expressions: vec![
         NamedExpression {
-          identifier: var_ids.from_name("a"),
+          identifier: var_ids.create_variable_from_name("a"),
           expression: Variable {
-            identifier: var_ids.from_name("n"),
+            identifier: var_ids.create_variable_from_name("n"),
           }
           .into(),
         },
         NamedExpression {
-          identifier: var_ids.from_name("b"),
+          identifier: var_ids.create_variable_from_name("b"),
           expression: Variable {
-            identifier: var_ids.from_name("m"),
+            identifier: var_ids.create_variable_from_name("m"),
           }
           .into(),
         },
@@ -193,7 +193,7 @@ pub(crate) fn double_with_return() -> Statements
       where_expression: None,
     }
     .into(),
-    return_statement(var_ids.from_name("a")),
+    return_statement(var_ids.create_variable_from_name("a")),
   ]
 }
 
@@ -203,14 +203,14 @@ pub(crate) fn unwind() -> Statements
   let var_ids = VariableIdentifiers::default();
   vec![
     Unwind {
-      identifier: var_ids.from_name("i"),
+      identifier: var_ids.create_variable_from_name("i"),
       expression: Array {
         array: vec![Value { value: 0.into() }.into()],
       }
       .into(),
     }
     .into(),
-    return_statement(var_ids.from_name("i")),
+    return_statement(var_ids.create_variable_from_name("i")),
   ]
 }
 
@@ -223,12 +223,12 @@ pub(crate) fn match_loop() -> Statements
       patterns: vec![Pattern::Edge(EdgePattern {
         variable: None,
         source: NodePattern {
-          variable: Some(var_ids.from_name("n")),
+          variable: Some(var_ids.create_variable_from_name("n")),
           labels: LabelExpression::None,
           properties: None,
         },
         destination: NodePattern {
-          variable: Some(var_ids.from_name("n")),
+          variable: Some(var_ids.create_variable_from_name("n")),
           labels: LabelExpression::None,
           properties: None,
         },
@@ -240,7 +240,7 @@ pub(crate) fn match_loop() -> Statements
       optional: false,
     }
     .into(),
-    return_statement(var_ids.from_name("n")),
+    return_statement(var_ids.create_variable_from_name("n")),
   ]
 }
 
@@ -251,7 +251,7 @@ pub(crate) fn optional_match() -> Statements
   vec![
     Match {
       patterns: vec![Pattern::Node(NodePattern {
-        variable: Some(var_ids.from_name("a")),
+        variable: Some(var_ids.create_variable_from_name("a")),
         labels: LabelExpression::None,
         properties: None,
       })],
@@ -259,7 +259,7 @@ pub(crate) fn optional_match() -> Statements
       optional: true,
     }
     .into(),
-    return_statement(var_ids.from_name("a")),
+    return_statement(var_ids.create_variable_from_name("a")),
   ]
 }
 
@@ -270,7 +270,7 @@ pub(crate) fn match_count() -> Statements
   vec![
     Match {
       patterns: vec![Pattern::Node(NodePattern {
-        variable: Some(var_ids.from_name("a")),
+        variable: Some(var_ids.create_variable_from_name("a")),
         labels: LabelExpression::None,
         properties: None,
       })],
@@ -281,7 +281,7 @@ pub(crate) fn match_count() -> Statements
     Return {
       all: false,
       expressions: vec![NamedExpression {
-        identifier: var_ids.from_name("count(*)"),
+        identifier: var_ids.create_variable_from_name("count(*)"),
         expression: FunctionCall {
           name: "count".into(),
           arguments: vec![Value { value: 0.into() }.into()],
@@ -306,7 +306,7 @@ pub(crate) fn aggregation() -> Statements
   vec![
     Match {
       patterns: vec![Pattern::Node(NodePattern {
-        variable: Some(var_ids.from_name("n")),
+        variable: Some(var_ids.create_variable_from_name("n")),
         labels: LabelExpression::None,
         properties: None,
       })],
@@ -318,10 +318,10 @@ pub(crate) fn aggregation() -> Statements
       all: false,
       expressions: vec![
         NamedExpression {
-          identifier: var_ids.from_name("n.name"),
+          identifier: var_ids.create_variable_from_name("n.name"),
           expression: MemberAccess {
             left: Variable {
-              identifier: var_ids.from_name("n"),
+              identifier: var_ids.create_variable_from_name("n"),
             }
             .into(),
             path: vec!["name".into()],
@@ -329,12 +329,12 @@ pub(crate) fn aggregation() -> Statements
           .into(),
         },
         NamedExpression {
-          identifier: var_ids.from_name("count(n.num)"),
+          identifier: var_ids.create_variable_from_name("count(n.num)"),
           expression: FunctionCall {
             name: "count".into(),
             arguments: vec![MemberAccess {
               left: Variable {
-                identifier: var_ids.from_name("n"),
+                identifier: var_ids.create_variable_from_name("n"),
               }
               .into(),
               path: vec!["num".into()],