gqlite 1.2.0 → 1.2.3

data/ext/gqliterb/vendor/gqlitedb/src/tests/evaluators.rs

@@ -0,0 +1,227 @@
+use crate::{
+  interpreter::evaluators::eval_program,
+  prelude::*,
+  store::{Store, TransactionBoxable},
+  tests::{check_stats, templates::programs},
+};
+
+#[test]
+fn test_evaluate_simple_create_node()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  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);
+}
+
+#[test]
+fn test_evaluate_create_named_node()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  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"]]
+  );
+}
+
+#[test]
+fn test_evaluate_create_named_node_double_return()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
+
+  let value = eval_program(
+    &store,
+    &programs::create_named_node_double_return(),
+    &Default::default(),
+  )
+  .unwrap();
+  check_stats(&store, None, 1, 0, 0, 2);
+
+  assert_eq!(
+    value,
+    value::array![value::array!["id", "p"], value::array![12, "foo"]]
+  );
+}
+
+#[test]
+fn test_evaluate_double_with_return()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  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]]);
+}
+
+#[test]
+fn test_evaluate_unwind()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  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]]);
+}
+
+#[test]
+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 mut tx = store.begin_write().unwrap();
+  store
+    .create_nodes(&mut tx, &"default".to_string(), vec![&node].into_iter())
+    .unwrap();
+  store
+    .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(),
+      }]
+      .into_iter(),
+    )
+    .unwrap();
+  tx.close().unwrap();
+
+  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]]
+  );
+}
+
+#[test]
+fn test_evaluate_optional_match()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  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]]
+  );
+}
+
+#[test]
+fn test_evaluate_match_count()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
+  let function_manager = functions::Manager::new();
+  let program = programs::match_count(&function_manager);
+
+  // Count 0
+  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]]
+  );
+
+  // Count 1
+  let node = graph::Node {
+    key: graph::Key { uuid: 1 },
+    labels: vec![],
+    properties: Default::default(),
+  };
+  let mut tx = store.begin_write().unwrap();
+  store
+    .create_nodes(&mut tx, &"default".to_string(), vec![&node].into_iter())
+    .unwrap();
+  tx.close().unwrap();
+  check_stats(&store, None, 1, 0, 0, 0);
+
+  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]]
+  );
+}
+
+#[test]
+fn test_evaluate_aggregation()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  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),
+    },
+  ];
+  let mut tx = store.begin_write().unwrap();
+  store
+    .create_nodes(&mut tx, &"default".to_string(), nodes.iter())
+    .unwrap();
+  tx.close().unwrap();
+  check_stats(&store, None, 3, 0, 0, 5);
+
+  let value = eval_program(&store, &program, &Default::default()).unwrap();
+  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,
+    value::array![
+      value::array!["n.name", "count(n.num)"],
+      value::array!["a", 1],
+      value::array!["b", 1]
+    ],
+  );
+}

data/ext/gqliterb/vendor/gqlitedb/src/tests/parser.rs

@@ -0,0 +1,81 @@
+use crate::{
+  parser::{self, parse},
+  tests::templates::ast,
+};
+
+fn compare_ast(actual: Vec<parser::ast::Statement>, expected: Vec<parser::ast::Statement>)
+{
+  assert_eq!(format!("{:?}", actual), format!("{:?}", expected));
+}
+
+#[test]
+fn test_parse_simple_create_node()
+{
+  let ast = parse("CREATE ()").unwrap();
+  let ast = ast.into_iter().next().unwrap();
+  compare_ast(ast, ast::simple_create_node())
+}
+
+#[test]
+fn test_parse_create_named_node()
+{
+  let ast = parse("CREATE (n {name: 'foo'}) RETURN n.name AS p").unwrap();
+  let ast = ast.into_iter().next().unwrap();
+  compare_ast(ast, ast::create_named_node())
+}
+
+#[test]
+fn test_parse_create_named_node_double_return()
+{
+  let ast = parse("CREATE (n {id: 12, name: 'foo'}) RETURN n.id AS id, n.name AS p").unwrap();
+  let ast = ast.into_iter().next().unwrap();
+  compare_ast(ast, ast::create_named_node_double_return())
+}
+
+#[test]
+fn test_parse_double_with_return()
+{
+  let ast = parse("WITH 1 AS n, 2 AS m WITH n AS a, m AS b RETURN a").unwrap();
+  let ast = ast.into_iter().next().unwrap();
+  compare_ast(ast, ast::double_with_return())
+}
+
+#[test]
+fn test_parse_unwind()
+{
+  let ast = parse("UNWIND [0] AS i RETURN i").unwrap();
+  let ast = ast.into_iter().next().unwrap();
+  compare_ast(ast, ast::unwind())
+}
+
+#[test]
+fn test_parse_match_loop()
+{
+  let ast = parse("MATCH (n)-[]->(n) RETURN n").unwrap();
+  let ast = ast.into_iter().next().unwrap();
+  compare_ast(ast, ast::match_loop());
+}
+
+#[test]
+fn test_parse_optional_match()
+{
+  let ast = parse("OPTIONAL MATCH (a) RETURN a").unwrap();
+  let ast = ast.into_iter().next().unwrap();
+  compare_ast(ast, ast::optional_match());
+}
+
+#[test]
+fn test_parse_match_count()
+{
+  let ast = parse("MATCH (a) RETURN count(*)").unwrap();
+  let ast = ast.into_iter().next().unwrap();
+  compare_ast(ast, ast::match_count());
+}
+
+#[test]
+fn test_parse_aggregation()
+{
+  let ast = parse("MATCH (n) RETURN n.name, count(n.num)").unwrap();
+  let ast = ast.into_iter().next().unwrap();
+  compare_ast(ast, ast::aggregation());
+}

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

@@ -0,0 +1,46 @@
+#[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::open(temp_file.path()).unwrap();
+  super::test_graphs(store);
+}
+
+#[test]
+fn test_select_nodes()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
+  super::test_select_nodes(store);
+}
+
+#[test]
+fn test_update_nodes()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
+  super::test_update_nodes(store);
+}
+
+#[test]
+fn test_select_edges()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
+  super::test_select_edges(store);
+}
+
+#[test]
+fn test_update_edges()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
+  super::test_update_edges(store);
+}

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

@@ -0,0 +1,46 @@
+#[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::sqlite::Store::open(temp_file.path()).unwrap();
+  super::test_graphs(store);
+}
+
+#[test]
+fn test_select_nodes()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  let store = crate::store::sqlite::Store::open(temp_file.path()).unwrap();
+  super::test_select_nodes(store);
+}
+
+#[test]
+fn test_update_nodes()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  let store = crate::store::sqlite::Store::open(temp_file.path()).unwrap();
+  super::test_update_nodes(store);
+}
+
+#[test]
+fn test_select_edges()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  let store = crate::store::sqlite::Store::open(temp_file.path()).unwrap();
+  super::test_select_edges(store);
+}
+
+#[test]
+fn test_update_edges()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  let store = crate::store::sqlite::Store::open(temp_file.path()).unwrap();
+  super::test_update_edges(store);
+}