ref composite filter and add search api tests

shivamka1 · shivamka1 · commit ab346497fb98 · 2025-01-17T13:38:45.000Z
diff --git a/raphtory/src/core/utils/errors.rs b/raphtory/src/core/utils/errors.rs
@@ -16,7 +16,8 @@ use std::{fmt::Debug, io, path::PathBuf, time::SystemTimeError};
 use tantivy;
 #[cfg(feature = "search")]
 use tantivy::query::QueryParserError;
-use crate::db::graph::views::property_filter::ComparisonOperator;
+use tracing::error;
+use crate::db::graph::views::property_filter::FilterOperator;
 
 #[derive(thiserror::Error, Debug)]
 pub enum InvalidPathReason {
@@ -296,13 +297,19 @@ pub enum GraphError {
     LockError,
 
     #[error("Operator {0} requires a property value, but none was provided.")]
-    InvalidFilter(ComparisonOperator),
+    InvalidFilter(FilterOperator),
 
     #[error("Property {0} not found in temporal or constant metadata")]
     PropertyNotFound(String),
 
     #[error("PropertyIndex not found for property {0}")]
-    PropertyIndexNotFound(String)
+    PropertyIndexNotFound(String),
+
+    #[error("Tokenization is support only for str field type")]
+    UnsupportedFieldTypeForTokenization,
+
+    #[error("Not tokens found")]
+    NoTokensFound,
 }
 
 impl GraphError {
diff --git a/raphtory/src/db/api/view/graph.rs b/raphtory/src/db/api/view/graph.rs
@@ -44,7 +44,7 @@ use std::{
     borrow::Borrow,
     sync::{atomic::Ordering, Arc},
 };
-use crate::db::graph::views::property_filter::CompositeFilter;
+use crate::db::graph::views::property_filter::CompositeNodeFilter;
 use crate::prelude::PropertyFilter;
 
 /// This trait GraphViewOps defines operations for accessing
@@ -136,7 +136,7 @@ pub trait SearchableGraphOps: Sized {
     fn search_nodes(
         &self,
         // q: &str,
-        filter: &CompositeFilter,
+        filter: &CompositeNodeFilter,
         limit: usize,
         offset: usize,
     ) -> Result<Vec<NodeView<Self>>, GraphError>;
@@ -626,7 +626,7 @@ impl<G: BoxableGraphView + Sized + Clone + 'static> SearchableGraphOps for G {
     fn search_nodes(
         &self,
         // q: &str,
-        filter: &CompositeFilter,
+        filter: &CompositeNodeFilter,
         limit: usize,
         offset: usize,
     ) -> Result<Vec<NodeView<Self>>, GraphError> {
diff --git a/raphtory/src/db/graph/views/property_filter/mod.rs b/raphtory/src/db/graph/views/property_filter/mod.rs
@@ -329,27 +329,27 @@ impl NodeFilter {
 }
 
 #[derive(Debug, Clone)]
-pub enum CompositeFilter {
-    SingleNode(NodeFilter),
-    SingleProperty(PropertyFilter),
-    And(Vec<CompositeFilter>),
-    Or(Vec<CompositeFilter>),
+pub enum CompositeNodeFilter {
+    Node(NodeFilter),
+    Property(PropertyFilter),
+    And(Vec<CompositeNodeFilter>),
+    Or(Vec<CompositeNodeFilter>),
 }
 
-impl fmt::Display for CompositeFilter {
+impl fmt::Display for CompositeNodeFilter {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            CompositeFilter::SingleProperty(filter) => write!(f, "{}", filter),
-            CompositeFilter::SingleNode(filter) => write!(f, "{}", filter),
-            CompositeFilter::And(filters) => {
+            CompositeNodeFilter::Property(filter) => write!(f, "{}", filter),
+            CompositeNodeFilter::Node(filter) => write!(f, "{}", filter),
+            CompositeNodeFilter::And(filters) => {
                 let formatted = filters
                     .iter()
                     .map(|filter| format!("({})", filter))
                     .collect::<Vec<String>>()
                     .join(" AND ");
                 write!(f, "{}", formatted)
             }
-            CompositeFilter::Or(filters) => {
+            CompositeNodeFilter::Or(filters) => {
                 let formatted = filters
                     .iter()
                     .map(|filter| format!("({})", filter))
@@ -364,34 +364,34 @@ impl fmt::Display for CompositeFilter {
 #[cfg(test)]
 mod test_filters {
     use crate::{
-        db::graph::views::property_filter::{CompositeFilter, NodeFilter},
+        db::graph::views::property_filter::{CompositeNodeFilter, NodeFilter},
         prelude::PropertyFilter,
     };
 
     #[test]
     fn test_composite_filter() {
         assert_eq!(
             "p2 == 2",
-            CompositeFilter::SingleProperty(PropertyFilter::eq("p2", 2u64)).to_string()
+            CompositeNodeFilter::Property(PropertyFilter::eq("p2", 2u64)).to_string()
         );
 
         assert_eq!(
             "((node_type NOT IN [fire_nation, water_tribe]) AND (p2 == 2) AND (p1 == 1) AND ((p3 <= 5) OR (p4 <= 1))) OR (node_name == pometry) OR (p5 == 9)",
-            CompositeFilter::Or(vec![
-                CompositeFilter::And(vec![
-                    CompositeFilter::SingleNode(NodeFilter::not_any(
+            CompositeNodeFilter::Or(vec![
+                CompositeNodeFilter::And(vec![
+                    CompositeNodeFilter::Node(NodeFilter::not_any(
                         "node_type",
                         vec!["fire_nation".into(), "water_tribe".into()]
                     )),
-                    CompositeFilter::SingleProperty(PropertyFilter::eq("p2", 2u64)),
-                    CompositeFilter::SingleProperty(PropertyFilter::eq("p1", 1u64)),
-                    CompositeFilter::Or(vec![
-                        CompositeFilter::SingleProperty(PropertyFilter::le("p3", 5u64)),
-                        CompositeFilter::SingleProperty(PropertyFilter::le("p4", 1u64))
+                    CompositeNodeFilter::Property(PropertyFilter::eq("p2", 2u64)),
+                    CompositeNodeFilter::Property(PropertyFilter::eq("p1", 1u64)),
+                    CompositeNodeFilter::Or(vec![
+                        CompositeNodeFilter::Property(PropertyFilter::le("p3", 5u64)),
+                        CompositeNodeFilter::Property(PropertyFilter::le("p4", 1u64))
                     ]),
                 ]),
-                CompositeFilter::SingleNode(NodeFilter::eq("node_name", "pometry")),
-                CompositeFilter::SingleProperty(PropertyFilter::eq("p5", 9u64)),
+                CompositeNodeFilter::Node(NodeFilter::eq("node_name", "pometry")),
+                CompositeNodeFilter::Property(PropertyFilter::eq("p5", 9u64)),
             ])
             .to_string()
         );
diff --git a/raphtory/src/search/query_executor.rs b/raphtory/src/search/query_executor.rs
@@ -4,7 +4,7 @@ use crate::{
         api::view::StaticGraphViewOps,
         graph::{
             node::NodeView,
-            views::property_filter::{CompositeFilter, NodeFilter},
+            views::property_filter::{CompositeNodeFilter, NodeFilter},
         },
     },
     prelude::{GraphViewOps, NodePropertyFilterOps, NodeViewOps, PropertyFilter, ResetFilter},
@@ -15,7 +15,7 @@ use raphtory_api::core::entities::VID;
 use std::{collections::HashSet, sync::Arc};
 use tantivy::{
     collector::{FilterCollector, TopDocs},
-    query::{Query},
+    query::Query,
     schema::{Field, Value},
     DocAddress, Document, Index, IndexReader, Score, Searcher, TantivyDocument,
 };
@@ -136,11 +136,11 @@ impl<'a> QueryExecutor<'a> {
                     limit,
                     offset,
                 )?
-            },
+            }
             None => {
                 println!("I was here");
                 vec![]
-            },
+            }
         };
 
         let unique_results: HashSet<_> = results.into_iter().collect();
@@ -157,18 +157,18 @@ impl<'a> QueryExecutor<'a> {
     pub fn execute<G: StaticGraphViewOps>(
         &self,
         graph: &G,
-        filter: &CompositeFilter,
+        filter: &CompositeNodeFilter,
         limit: usize,
         offset: usize,
     ) -> Result<HashSet<NodeView<G, G>>, GraphError> {
         match filter {
-            CompositeFilter::SingleProperty(filter) => {
+            CompositeNodeFilter::Property(filter) => {
                 self.execute_property_filter(graph, filter, limit, offset)
             }
-            CompositeFilter::SingleNode(filter) => {
+            CompositeNodeFilter::Node(filter) => {
                 self.execute_node_filter(graph, filter, limit, offset)
             }
-            CompositeFilter::And(filters) => {
+            CompositeNodeFilter::And(filters) => {
                 let mut results = None;
 
                 for sub_filter in filters {
@@ -182,7 +182,7 @@ impl<'a> QueryExecutor<'a> {
 
                 Ok(results.unwrap_or_default())
             }
-            CompositeFilter::Or(filters) => {
+            CompositeNodeFilter::Or(filters) => {
                 let mut results = HashSet::new();
 
                 for sub_filter in filters {
@@ -248,10 +248,7 @@ impl<'a> QueryExecutor<'a> {
     fn print_schema_fields(schema: &tantivy::schema::Schema) {
         println!("Schema fields and their IDs:");
         for (field_name, field_entry) in schema.fields() {
-            println!(
-                "Field Name: '{:?}'",
-                field_name,
-            );
+            println!("Field Name: '{:?}'", field_name,);
         }
     }
 
diff --git a/raphtory/src/search/searcher.rs b/raphtory/src/search/searcher.rs
