gqlite 1.5.0 → 1.7.0

data/ext/gqlitedb/src/tests/connection.rs

@@ -1,7 +1,11 @@
 #[cfg(all(feature = "postgres", not(windows)))]
 pub(crate) mod postgres;
+#[cfg(feature = "redb")]
+mod redb;
+#[cfg(feature = "sqlite")]
+pub(crate) mod sqlite;
 
-fn test_connection(connection: crate::Connection)
+fn test_create_match_return(connection: crate::Connection)
 {
   connection
     .execute_oc_query("CREATE (n:a)", Default::default())
@@ -14,6 +18,62 @@ fn test_connection(connection: crate::Connection)
   assert_eq!(table.rows(), 1);
   assert_eq!(*table.headers(), vec!["n".to_string()]);
   let node: graphcore::Node = table.value(0, 0).unwrap().try_into().unwrap();
+  println!("{node:?}");
+  assert_eq!(node.graph_name().as_ref().unwrap(), "default");
   assert_eq!(*node.labels(), vec!["a".to_string()]);
   assert_eq!(node.properties().len(), 0);
 }
+
+fn test_create_return(connection: crate::Connection)
+{
+  let r = connection
+    .execute_oc_query("CREATE (n:a) RETURN n", Default::default())
+    .unwrap();
+  let table = r.try_into_table().unwrap();
+  assert_eq!(table.columns(), 1);
+  assert_eq!(table.rows(), 1);
+  assert_eq!(*table.headers(), vec!["n".to_string()]);
+  let node: graphcore::Node = table.value(0, 0).unwrap().try_into().unwrap();
+  println!("{node:?}");
+  assert_eq!(node.graph_name().as_ref().unwrap(), "default");
+  assert_eq!(*node.labels(), vec!["a".to_string()]);
+  assert_eq!(node.properties().len(), 0);
+}
+
+fn test_create_edge_return(connection: crate::Connection)
+{
+  let r = connection
+    .execute_oc_query("CREATE ()-[e:a]->() RETURN e", Default::default())
+    .unwrap();
+  let table = r.try_into_table().unwrap();
+  assert_eq!(table.columns(), 1);
+  assert_eq!(table.rows(), 1);
+  assert_eq!(*table.headers(), vec!["e".to_string()]);
+  let edge: graphcore::Edge = table.value(0, 0).unwrap().try_into().unwrap();
+  println!("{edge:?}");
+  assert_eq!(edge.graph_name().as_ref().unwrap(), "default");
+  assert_eq!(*edge.labels(), vec!["a".to_string()]);
+  assert_eq!(edge.properties().len(), 0);
+}
+
+fn test_vector_search_dimension_mismatch(connection: crate::Connection)
+{
+  connection
+    .execute_oc_query(
+      "CREATE (:Doc { embedding: [0.1, 0.2, 0.3], title: 'doc1' })",
+      Default::default(),
+    )
+    .unwrap();
+  connection
+    .execute_oc_query(
+      "CREATE VECTOR INDEX doc_idx ON :Doc (embedding) OPTIONS { dimension: 3, metric: \"cosine\" }",
+      Default::default(),
+    )
+    .unwrap();
+
+  let result = connection.execute_oc_query(
+    "MATCH (n:Doc) SEARCH n IN (VECTOR INDEX doc_idx FOR [0.5, 0.5] LIMIT 1) RETURN n.title",
+    Default::default(),
+  );
+  assert!(result.is_err(), "dimension mismatch should raise an error");
+}

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

@@ -1,6 +1,9 @@
 use crate::{
+  compiler::compile,
   interpreter::evaluators::eval_program,
+  planner,
   prelude::*,
+  query_result::QueryResult,
   store::{Store, TransactionBoxable},
   tests::{check_stats, templates::programs},
 };
@@ -74,18 +77,21 @@ 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::new(graph::Key::new(1), vec![], Default::default());
+  let node = graph::Node::new(
+    Some("default".into()),
+    graph::Key::new(1),
+    vec![],
+    Default::default(),
+  );
   let mut tx = store.begin_write().unwrap();
   store.create_nodes(&mut tx, "default", vec![&node]).unwrap();
   store
     .create_edges(
       &mut tx,
       "default",
-      vec![&graph::Path::new(
-        graph::Key::new(2),
+      vec![&graph::SinglePath::new(
         node.clone(),
-        vec![],
-        Default::default(),
+        graph::Edge::new(None, graph::Key::new(2), vec![], Default::default()),
         node.clone(),
       )],
     )
@@ -125,7 +131,7 @@ fn test_evaluate_match_count()
   assert_eq!(value, crate::table![("count(*)"), [[0]]].into());
 
   // Count 1
-  let node = graph::Node::new(graph::Key::new(1), vec![], Default::default());
+  let node = graph::Node::new(None, graph::Key::new(1), vec![], Default::default());
   let mut tx = store.begin_write().unwrap();
   store.create_nodes(&mut tx, "default", vec![&node]).unwrap();
   tx.close().unwrap();
@@ -147,12 +153,19 @@ fn test_evaluate_aggregation()
 
   let nodes = [
     graph::Node::new(
+      None,
       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(
+      None,
+      graph::Key::new(2),
+      vec![],
+      value::value_map!("name" => "a"),
+    ),
+    graph::Node::new(
+      None,
       graph::Key::new(3),
       vec![],
       value::value_map!("name" => "b", "num" => 42),
@@ -176,3 +189,145 @@ fn test_evaluate_aggregation()
     crate::table![("n.name", "count(n.num)"), [["a", 1], ["b", 1]]],
   );
 }
+
+fn run_query(store: &impl Store, source: &str) -> Result<QueryResult>
+{
+  let function_manager = functions::Manager::new();
+  let queries = gqlparser::oc::parse_oc_query(source).map_err(|_| {
+    error::Error::CompileTime(error::CompileTimeError::ParseError {
+      error_kind: gqlparser::oc::ErrorKind::UnexpectedToken,
+      text: source.to_string(),
+      span: 0..source.len(),
+    })
+  })?;
+  let statements = queries
+    .into_iter()
+    .next()
+    .and_then(|q| match q
+    {
+      gqlparser::oc::ast::Query::Statements(s) => Some(s),
+      _ => None,
+    })
+    .ok_or_else(|| {
+      error::Error::CompileTime(error::CompileTimeError::UnexpectedSyntax {
+        expected: "statements".to_string(),
+        got: "other".to_string(),
+        line: 0,
+        col: 0,
+      })
+    })?;
+  let program = compile(
+    &function_manager,
+    statements
+      .into_iter()
+      .map(planner::plan)
+      .collect::<Result<Vec<_>, _>>()?,
+  )?;
+  eval_program(store, &program, &Default::default())
+}
+
+#[test]
+fn test_vector_search_on_non_default_graph_after_use()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
+
+  // Single index, single graph, never touching "default" at all -- the
+  // minimal reproduction of the bug report.
+  run_query(&store, "CREATE GRAPH g1").unwrap();
+  run_query(
+    &store,
+    "USE g1 CREATE (:Doc {title: 'A', embedding: [1.0, 0.0, 0.0]})",
+  )
+  .unwrap();
+  run_query(
+    &store,
+    "USE g1 CREATE VECTOR INDEX idx ON :Doc (embedding) OPTIONS { dimension: 3, metric: \"cosine\" }",
+  )
+  .unwrap();
+
+  // EXPECTED TO FAIL before #444: this currently raises
+  // StoreError::InvalidFormat("Vector index 'idx' does not exist in graph 'default'")
+  // because LogicalPlan::VectorSearch hardcodes graph: "default" at plan
+  // time (planner.rs), regardless of the USE g1 immediately above.
+  let result = run_query(
+    &store,
+    "USE g1 MATCH (n:Doc) SEARCH n IN (VECTOR INDEX idx FOR [1.0, 0.0, 0.0] LIMIT 1) RETURN n.title",
+  );
+  assert!(
+    result.is_ok(),
+    "expected search on g1 to find idx registered on g1, got: {:?}",
+    result
+  );
+}
+
+#[test]
+fn test_vector_search_multiple_indexes_same_graph()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
+
+  run_query(&store, "CREATE GRAPH g1").unwrap();
+  run_query(
+    &store,
+    "USE g1 CREATE (:Doc {title: 'A', embedding: [1.0, 0.0, 0.0]}) \
+     CREATE (:Note {title: 'B', tags: [0.0, 1.0, 0.0]})",
+  )
+  .unwrap();
+  run_query(
+    &store,
+    "USE g1 CREATE VECTOR INDEX idx_doc ON :Doc (embedding) OPTIONS { dimension: 3, metric: \"cosine\" }",
+  )
+  .unwrap();
+  run_query(
+    &store,
+    "USE g1 CREATE VECTOR INDEX idx_note ON :Note (tags) OPTIONS { dimension: 3, metric: \"cosine\" }",
+  )
+  .unwrap();
+
+  // EXPECTED TO FAIL before #444, same root cause as above.
+  let doc_result = run_query(
+    &store,
+    "USE g1 MATCH (n:Doc) SEARCH n IN (VECTOR INDEX idx_doc FOR [1.0, 0.0, 0.0] LIMIT 1) RETURN n.title",
+  );
+  assert!(doc_result.is_ok());
+
+  let note_result = run_query(
+    &store,
+    "USE g1 MATCH (n:Note) SEARCH n IN (VECTOR INDEX idx_note FOR [0.0, 1.0, 0.0] LIMIT 1) RETURN n.title",
+  );
+  assert!(note_result.is_ok());
+}
+
+#[test]
+fn test_vector_search_after_switching_between_two_graphs()
+{
+  let temp_file = crate::tests::create_tmp_file();
+  let store = crate::store::redb::Store::open(temp_file.path()).unwrap();
+
+  run_query(&store, "CREATE GRAPH g1 CREATE GRAPH g2").unwrap();
+  run_query(
+    &store,
+    "USE g1 CREATE (:Doc {title: 'A', embedding: [1.0, 0.0, 0.0]}) \
+     CREATE VECTOR INDEX idx1 ON :Doc (embedding) OPTIONS { dimension: 3, metric: \"cosine\" }",
+  )
+  .unwrap();
+  run_query(
+    &store,
+    "USE g2 CREATE (:Doc {title: 'B', embedding: [0.0, 1.0, 0.0]}) \
+     CREATE VECTOR INDEX idx2 ON :Doc (embedding) OPTIONS { dimension: 3, metric: \"cosine\" }",
+  )
+  .unwrap();
+
+  // After switching back to g1, idx1 must resolve against g1 -- direct
+  // multi-USE regression case. EXPECTED TO FAIL before WI 3.
+  let result = run_query(
+    &store,
+    "USE g1 MATCH (n:Doc) SEARCH n IN (VECTOR INDEX idx1 FOR [1.0, 0.0, 0.0] LIMIT 1) RETURN n.title",
+  );
+  assert!(
+    result.is_ok(),
+    "idx1 must be found on g1 after switching away and back: {:?}",
+    result
+  );
+}

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

@@ -1,81 +1,112 @@
-use crate::{
-  parser::{self, parse},
-  tests::templates::ast,
-};
+use gqlparser::oc::{self, parse_oc_query as parse};
 
-fn compare_ast(actual: Vec<parser::ast::Statement>, expected: Vec<parser::ast::Statement>)
+use crate::tests::templates::ast;
+
+fn compare_ast(actual: Vec<oc::ast::Statement>, expected: Vec<oc::ast::Statement>)
 {
   assert_eq!(format!("{:?}", actual), format!("{:?}", expected));
 }
 
+fn parse_query(source: &str) -> Vec<oc::ast::Statement>
+{
+  let queries = parse(source).unwrap();
+  let oc::ast::Query::Statements(ast) = queries.into_iter().next().unwrap()
+  else
+  {
+    panic!("Expected Statements query");
+  };
+  ast
+}
+
 #[test]
 fn test_parse_simple_create_node()
 {
-  let ast = parse("CREATE ()").unwrap();
-  let ast = ast.into_iter().next().unwrap();
+  let ast = parse_query("CREATE ()");
   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();
+  let ast = parse_query("CREATE (n {name: 'foo'}) RETURN n.name AS p");
   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();
+  let ast = parse_query("CREATE (n {id: 12, name: 'foo'}) RETURN n.id AS id, n.name AS p");
   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();
+  let ast = parse_query("WITH 1 AS n, 2 AS m WITH n AS a, m AS b RETURN a");
   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();
+  let ast = parse_query("UNWIND [0] AS i RETURN i");
   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();
+  let ast = parse_query("MATCH (n)-[]->(n) RETURN n");
   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();
+  let ast = parse_query("OPTIONAL MATCH (a) RETURN a");
   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();
+  let ast = parse_query("MATCH (a) RETURN count(*)");
   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();
+  let ast = parse_query("MATCH (n) RETURN n.name, count(n.num)");
   compare_ast(ast, ast::aggregation());
 }
+
+#[test]
+fn test_parse_create_vector_index()
+{
+  let ast = parse_query(
+    "CREATE VECTOR INDEX idx ON :Doc (embedding) OPTIONS { dimension: 3, metric: \"cosine\" }",
+  );
+  compare_ast(ast, ast::create_vector_index("idx"))
+}
+
+#[test]
+fn test_parse_match_with_vector_search()
+{
+  let ast = parse_query(
+    "MATCH (n:Doc) SEARCH n IN (VECTOR INDEX idx FOR [0.1, 0.2, 0.3] LIMIT 2) RETURN n.title AS p",
+  );
+  compare_ast(ast, ast::match_with_vector_search("idx"))
+}
+
+#[test]
+fn test_parse_multiple_vector_index_creation()
+{
+  let ast = parse_query(
+    "CREATE VECTOR INDEX idx1 ON :Doc (embedding) OPTIONS { dimension: 3, metric: \"cosine\" } \
+     CREATE VECTOR INDEX idx2 ON :Doc (embedding) OPTIONS { dimension: 3, metric: \"cosine\" }",
+  );
+  let mut expected = ast::create_vector_index("idx1");
+  expected.extend(ast::create_vector_index("idx2"));
+  compare_ast(ast, expected)
+}