gqlite 1.8.0 → 1.8.2

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

@@ -41,3 +41,25 @@ fn test_vector_search_dimension_mismatch()
   let connection = builder.create().unwrap();
   super::test_vector_search_dimension_mismatch(connection);
 }
+
+#[test]
+fn test_not_wraps_comparison_at_runtime()
+{
+  let db = crate::tests::postgres::create_tmp_db(14);
+  let builder = crate::Connection::builder()
+    .set_option("url", db.connection_uri())
+    .backend(crate::Backend::Postgres);
+  let connection = builder.create().unwrap();
+  super::test_not_wraps_comparison_at_runtime(connection);
+}
+
+#[test]
+fn test_count_distinct_end_to_end()
+{
+  let db = crate::tests::postgres::create_tmp_db(15);
+  let builder = crate::Connection::builder()
+    .set_option("url", db.connection_uri())
+    .backend(crate::Backend::Postgres);
+  let connection = builder.create().unwrap();
+  super::test_count_distinct_end_to_end(connection);
+}

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

@@ -21,3 +21,27 @@ fn test_create_edge_return()
   let connection = builder.create().unwrap();
   super::test_create_edge_return(connection);
 }
+
+#[test]
+fn test_not_wraps_comparison_at_runtime()
+{
+  let builder = crate::Connection::builder().backend(crate::Backend::Redb);
+  let connection = builder.create().unwrap();
+  super::test_not_wraps_comparison_at_runtime(connection);
+}
+
+#[test]
+fn test_count_distinct_end_to_end()
+{
+  let builder = crate::Connection::builder().backend(crate::Backend::Redb);
+  let connection = builder.create().unwrap();
+  super::test_count_distinct_end_to_end(connection);
+}
+
+#[test]
+fn test_shortest_with_explicit_minimum_hop_count()
+{
+  let builder = crate::Connection::builder().backend(crate::Backend::Redb);
+  let connection = builder.create().unwrap();
+  super::test_shortest_with_explicit_minimum_hop_count(connection);
+}

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

@@ -29,3 +29,19 @@ fn test_vector_search_dimension_mismatch()
   let connection = builder.create().unwrap();
   super::test_vector_search_dimension_mismatch(connection);
 }
+
+#[test]
+fn test_not_wraps_comparison_at_runtime()
+{
+  let builder = crate::Connection::builder().backend(crate::Backend::SQLite);
+  let connection = builder.create().unwrap();
+  super::test_not_wraps_comparison_at_runtime(connection);
+}
+
+#[test]
+fn test_count_distinct_end_to_end()
+{
+  let builder = crate::Connection::builder().backend(crate::Backend::SQLite);
+  let connection = builder.create().unwrap();
+  super::test_count_distinct_end_to_end(connection);
+}

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

@@ -77,3 +77,104 @@ fn test_vector_search_dimension_mismatch(connection: crate::Connection)
   );
   assert!(result.is_err(), "dimension mismatch should raise an error");
 }
+
+fn test_not_wraps_comparison_at_runtime(connection: crate::Connection)
+{
+  connection
+    .execute_oc_query("CREATE (:Person {name: \"Alice\"})", Default::default())
+    .unwrap();
+  connection
+    .execute_oc_query("CREATE (:Person {name: \"Bob\"})", Default::default())
+    .unwrap();
+
+  let result = connection
+    .execute_oc_query(
+      r#"MATCH (p:Person) WHERE NOT p.name = "Alice" RETURN count(p) AS n"#,
+      Default::default(),
+    )
+    .unwrap();
+  let table = result.try_into_table().unwrap();
+  assert_eq!(table.rows(), 1);
+  let count: i64 = table.value(0, 0).unwrap().try_into().unwrap();
+  assert_eq!(count, 1, "only Bob should match (NOT Alice)");
+}
+
+fn test_count_distinct_end_to_end(connection: crate::Connection)
+{
+  connection
+    .execute_oc_query("CREATE (:Person {id: 1})", Default::default())
+    .unwrap();
+  connection
+    .execute_oc_query("CREATE (:Person {id: 2})", Default::default())
+    .unwrap();
+  connection
+    .execute_oc_query("CREATE (:Person {id: 3})", Default::default())
+    .unwrap();
+
+  connection
+    .execute_oc_query(
+      "MATCH (p:Person {id: 1}), (f:Person) CREATE (p)-[:KNOWS]->(f)",
+      Default::default(),
+    )
+    .unwrap();
+  connection
+    .execute_oc_query(
+      "MATCH (p:Person {id: 1}), (f:Person {id: 2}) CREATE (p)-[:KNOWS]->(f)",
+      Default::default(),
+    )
+    .unwrap();
+  connection
+    .execute_oc_query(
+      "MATCH (p:Person {id: 1}), (f:Person {id: 3}) CREATE (p)-[:KNOWS]->(f)",
+      Default::default(),
+    )
+    .unwrap();
+
+  let result = connection
+    .execute_oc_query(
+      "MATCH (p:Person {id: 1})-[:KNOWS]->(friend:Person) RETURN count(DISTINCT friend) AS n",
+      Default::default(),
+    )
+    .unwrap();
+  let table = result.try_into_table().unwrap();
+  assert_eq!(table.rows(), 1);
+  let count: i64 = table.value(0, 0).unwrap().try_into().unwrap();
+  assert_eq!(count, 3, "should count distinct friends");
+}
+
+fn test_shortest_with_explicit_minimum_hop_count(connection: crate::Connection)
+{
+  connection
+    .execute_oc_query(
+      r#"
+      CREATE (a:Station {name: 'A'}),
+             (x:Station {name: 'X'}),
+             (d:Station {name: 'D'}),
+             (a)-[:LINK]->(d),
+             (a)-[:LINK]->(x),
+             (x)-[:LINK]->(d)
+      "#,
+      Default::default(),
+    )
+    .unwrap();
+
+  let result = connection
+    .execute_oc_query(
+      r#"MATCH p = SHORTEST 1 (a:Station {name: 'A'})-[:LINK*2..4]->(d:Station {name: 'D'}) RETURN length(p) AS len"#,
+      Default::default(),
+    )
+    .unwrap();
+
+  let table = result.try_into_table().unwrap();
+  assert_eq!(
+    table.rows(),
+    1,
+    "should find exactly one path with min_hops=2, got {} rows",
+    table.rows()
+  );
+  let len: i64 = table.value(0, 0).unwrap().try_into().unwrap();
+  assert_eq!(
+    len, 2,
+    "should return path of length 2 (A->X->D), not the direct 1-hop edge (A->D)"
+  );
+}