Impl index based filtering for Raphtory APIs alongside Search APIs

Cargo.toml

@@ -94,7 +94,7 @@ quad-rand = "0.2.1"
 zip = "2.1.3"
 neo4rs = "0.8.0"
 bzip2 = "0.4.4"
-tantivy = "0.22"
+tantivy = "0.22.0"
 async-trait = "0.1.77"
 async-openai = "0.26.0"
 oauth2 = "4.0"
@@ -156,3 +156,4 @@ arrow-data = { version = "53.2.0" }
 arrow-ipc = { version = "53.2.0" }
 moka = { version = "0.12.7", features = ["sync"] }
 indexmap = { version = "2.7.0", features = ["rayon"] }
+fake = { version = "3.1.0", features = ["chrono"]  }

js-raphtory/src/graph/graph_view_impl.rs

@@ -0,0 +1,22 @@
+use super::{Graph, UnderGraph};
+use raphtory::db::api::view::{
+    internal::{InheritIndexSearch, InheritNodeHistoryFilter},
+    Base, BoxableGraphView, InheritViewOps,
+};
+
+impl Base for Graph {
+    type Base = dyn BoxableGraphView + Send + Sync + 'static;
+
+    fn base(&self) -> &(dyn BoxableGraphView + Send + Sync + 'static) {
+        match &self.0 {
+            UnderGraph::TGraph(g) => g.as_ref(),
+            UnderGraph::WindowedGraph(g) => g.as_ref(),
+        }
+    }
+}
+
+impl InheritViewOps for Graph {}
+
+impl InheritIndexSearch for Graph {}
+
+impl InheritNodeHistoryFilter for Graph {}

python/tests/test_graphdb/test_graphdb.py

@@ -2956,44 +2956,42 @@ def test_fuzzy_search():
 
     # @with_disk_graph # FIXME: Indexing doesn't seem to return layers and doesn't pass the layer id to the storage blowing up in the storage
     def check(g):
-        index = g.index()
-
-        assert len(index.fuzzy_search_nodes("name:habza", levenshtein_distance=1)) == 1
+        assert len(g.fuzzy_search_nodes("name:habza", levenshtein_distance=1)) == 1
         assert (
             len(
-                index.fuzzy_search_nodes(
+                g.fuzzy_search_nodes(
                     "name:haa", levenshtein_distance=1, prefix=True
                 )
             )
             == 2
         )
         assert (
             len(
-                index.fuzzy_search_nodes(
+                g.fuzzy_search_nodes(
                     "value_str:abc123", levenshtein_distance=2, prefix=True
                 )
             )
             == 2
         )
         assert (
             len(
-                index.fuzzy_search_nodes(
+                g.fuzzy_search_nodes(
                     "value_str:dsss312", levenshtein_distance=2, prefix=False
                 )
             )
             == 1
         )
 
-        assert len(index.fuzzy_search_edges("from:bon", levenshtein_distance=1)) == 2
+        assert len(g.fuzzy_search_edges("from:bon", levenshtein_distance=1)) == 2
         assert (
             len(
-                index.fuzzy_search_edges("from:bo", levenshtein_distance=1, prefix=True)
+                g.fuzzy_search_edges("from:bo", levenshtein_distance=1, prefix=True)
             )
             == 2
         )
         assert (
             len(
-                index.fuzzy_search_edges(
+                g.fuzzy_search_edges(
                     "from:eon", levenshtein_distance=2, prefix=True
                 )
             )

python/tests/test_index.py

@@ -47,32 +47,30 @@ def test_search_in_python():
         },
     )
 
-    index = g.index()
-
     # Name tests
-    assert len(index.search_nodes("name:ben")) == 1
-    assert len(index.search_nodes("name:ben OR name:hamza")) == 2
-    assert len(index.search_nodes("name:ben AND name:hamza")) == 0
-    assert len(index.search_nodes("name: IN [ben, hamza]")) == 2
+    assert len(g.search_nodes("name:ben")) == 1
+    assert len(g.search_nodes("name:ben OR name:hamza")) == 2
+    assert len(g.search_nodes("name:ben AND name:hamza")) == 0
+    assert len(g.search_nodes("name: IN [ben, hamza]")) == 2
 
     # Property tests
-    # assert len(index.search_nodes("value:<120 OR value_f:>30")) == 3
-    assert len(index.search_nodes("value:199")) == 1
-    # assert len(index.search_nodes("value:[0 TO 60]")) == 2
-    # assert len(index.search_nodes("value:[0 TO 60}")) == 1  # } == exclusive
-    # assert len(index.search_nodes("value:>59 AND value_str:abc123")) == 1
+    # assert len(g.search_nodes("value:<120 OR value_f:>30")) == 3
+    assert len(g.search_nodes("value:199")) == 1
+    # assert len(g.search_nodes("value:[0 TO 60]")) == 2
+    # assert len(g.search_nodes("value:[0 TO 60}")) == 1  # } == exclusive
+    # assert len(g.search_nodes("value:>59 AND value_str:abc123")) == 1
 
     # edge tests
-    assert len(index.search_edges("from:ben")) == 2
-    assert len(index.search_edges("from:ben OR from:haaroon")) == 3
-    assert len(index.search_edges("to:haaroon AND from:ben")) == 1
-    assert len(index.search_edges("to: IN [ben, hamza]")) == 2
+    assert len(g.search_edges("from:ben")) == 2
+    assert len(g.search_edges("from:ben OR from:haaroon")) == 3
+    assert len(g.search_edges("to:haaroon AND from:ben")) == 1
+    assert len(g.search_edges("to: IN [ben, hamza]")) == 2
 
     # edge prop tests
-    # assert len(index.search_edges("value:<120 OR value_f:>30")) == 3
-    # assert len(index.search_edges("value:[0 TO 60]")) == 2
-    # assert len(index.search_edges("value:[0 TO 60}")) == 1  # } == exclusive
-    # assert len(index.search_edges("value:>59 AND value_str:abc123")) == 1
+    # assert len(g.search_edges("value:<120 OR value_f:>30")) == 3
+    # assert len(g.search_edges("value:[0 TO 60]")) == 2
+    # assert len(g.search_edges("value:[0 TO 60}")) == 1  # } == exclusive
+    # assert len(g.search_edges("value:>59 AND value_str:abc123")) == 1
 
     # Multiple history points test
     g = Graph()
@@ -86,25 +84,22 @@ def test_search_in_python():
         3, "hamza", properties={"value": 80, "value_f": 11.3, "value_str": "dsc2312"}
     )
 
-    index = g.index()
-
     # The semantics here are that the expressions independently need to evaluate at ANY point in the lifetime of the node - hence hamza is returned even though at no point does he have both these values at the same time
-    # assert len(index.search_nodes("value:<70 AND value_f:<19.2")) == 1
+    # assert len(g.search_nodes("value:<70 AND value_f:<19.2")) == 1
 
     g.add_node(
         4, "hamza", properties={"value": 100, "value_f": 11.3, "value_str": "dsc2312"}
     )
     # the graph isn't currently reindexed so this will not return hamza even though he now has a value which fits the bill
-    # assert len(index.search_nodes("value:>99")) == 0
+    # assert len(g.search_nodes("value:>99")) == 0
 
 
 def test_type_search():
     g = Graph()
     ben = g.add_node(1, "ben", node_type="type_1")
     hamza = g.add_node(2, "hamza", node_type="type_2")
-    indexed = g.index()
-    assert indexed.search_nodes("node_type:type_1") == [ben]
-    assert set(indexed.search_nodes("node_type:type_1 OR node_type:type_2")) == {
+    assert g.search_nodes("node_type:type_1") == [ben]
+    assert set(g.search_nodes("node_type:type_1 OR node_type:type_2")) == {
         hamza,
         ben,
     }
@@ -150,16 +145,15 @@ def test_search_with_windows():
 
     w_g = g.window(1, 3)
 
-    w_index = w_g.index()
 
     # Testing if windowing works - ben shouldn't be included and Hamza should only have max value of 70
-    assert len(w_index.search_nodes("name:ben")) == 0
-    assert len(w_index.search_nodes("value:70")) == 1
+    assert len(w_g.search_nodes("name:ben")) == 0
+    assert len(w_g.search_nodes("value:70")) == 1
     # assert len(w_index.search_nodes("value:>80")) == 0
 
-    assert len(w_index.search_edges("from:ben")) == 0
+    assert len(w_g.search_edges("from:ben")) == 0
     # assert len(w_index.search_edges("from:haaroon AND value:>70")) == 0
-    assert len(w_index.search_edges("from:haaroon AND to:hamza")) == 1
+    assert len(w_g.search_edges("from:haaroon AND to:hamza")) == 1
 
 
 def test_search_with_subgraphs():
@@ -188,10 +182,8 @@ def test_search_with_subgraphs():
     )
     g.add_edge(4, "hamza", "naomi")
 
-    index = g.index()
-    assert len(index.search_edges("from:hamza OR to:hamza")) == 3
+    assert len(g.search_edges("from:hamza OR to:hamza")) == 3
 
     subgraph = g.subgraph([g.node("ben"), g.node("hamza"), g.node("haaroon")])
-    index = subgraph.index()
 
-    assert len(index.search_edges("from:hamza OR to:hamza")) == 2
+    assert len(subgraph.search_edges("from:hamza OR to:hamza")) == 2

raphtory-benchmark/Cargo.toml

@@ -9,15 +9,12 @@ edition = "2021"
 criterion = { workspace = true }
 raphtory = { path = "../raphtory", features = ["io", "proto"], version = "0.14.0" }
 raphtory-api = { path = "../raphtory-api", version = "0.14.0" }
-pometry-storage.workspace = true
 sorted_vector_map = { workspace = true }
 rand = { workspace = true }
 rayon = { workspace = true }
 tempfile = { workspace = true }
-clap = { workspace = true }
-csv = { workspace = true }
-flate2 = { workspace = true }
 tracing = {workspace = true}
+once_cell = { workspace = true }
 
 [[bench]]
 name = "tgraph_benchmarks"
@@ -58,3 +55,10 @@ harness = false
 # [[bench]]
 # name = "arrow_algobench"
 # harness = false
+
+[[bench]]
+name = "search_bench"
+harness = false
+
+[features]
+search = ["raphtory/search"]