Filter expr wip

Cargo.toml

@@ -71,7 +71,7 @@ async-graphql = { version = "7.2.1", features = ["dynamic-schema"] }
 async-graphql-poem = "7.2.1"
 dynamic-graphql = "0.10.2"
 derive_more = "2.1.1"
-tikv-jemallocator = "0.6.1"
+tikv-jemallocator = "0.7.0"
 reqwest = { version = "0.13.3", default-features = false, features = [
     "multipart",
     "json",

raphtory-api/src/core/entities/properties/prop/mod.rs

@@ -12,7 +12,6 @@ mod serde;
 mod template;
 
 pub use arrow::*;
-
 pub use prop_array::*;
 pub use prop_enum::*;
 pub use prop_ref_enum::*;

raphtory-graphql/schema.graphql

@@ -5614,4 +5614,3 @@ schema {
 	query: QueryRoot
 	mutation: MutRoot
 }
-

raphtory-graphql/src/model/graph/filtering.rs

@@ -9,7 +9,7 @@ use dynamic_graphql::{
 use raphtory::{
     db::graph::views::filter::model::{
         edge_filter::{CompositeEdgeFilter, EdgeFilter},
-        filter::{Filter, FilterValue},
+        filter::{FieldFilterValue, Filter},
         filter_operator::FilterOperator,
         graph_filter::GraphFilter,
         is_active_edge_filter::IsActiveEdge,
@@ -1028,17 +1028,17 @@ fn require_u64_value(op: &str, v: &Value) -> Result<u64, GraphError> {
     }
 }
 
-fn parse_node_id_scalar(op: &str, v: &Value) -> Result<FilterValue, GraphError> {
+fn parse_node_id_scalar(op: &str, v: &Value) -> Result<FieldFilterValue, GraphError> {
     match v {
-        Value::U64(i) => Ok(FilterValue::ID(GID::U64(*i))),
-        Value::Str(s) => Ok(FilterValue::ID(GID::Str(s.clone()))),
+        Value::U64(i) => Ok(FieldFilterValue::ID(GID::U64(*i))),
+        Value::Str(s) => Ok(FieldFilterValue::ID(GID::Str(s.clone()))),
         other => Err(GraphError::InvalidGqlFilter(format!(
             "{op} requires int or str, got {other}"
         ))),
     }
 }
 
-fn parse_node_id_list(op: &str, v: &Value) -> Result<FilterValue, GraphError> {
+fn parse_node_id_list(op: &str, v: &Value) -> Result<FieldFilterValue, GraphError> {
     let Value::List(vs) = v else {
         return Err(GraphError::InvalidGqlFilter(format!(
             "{op} requires a list value, got {v}"
@@ -1067,10 +1067,10 @@ fn parse_node_id_list(op: &str, v: &Value) -> Result<FilterValue, GraphError> {
             }
         }
     }
-    Ok(FilterValue::IDSet(Arc::new(set)))
+    Ok(FieldFilterValue::IDSet(Arc::new(set)))
 }
 
-fn parse_string_list(op: &str, v: &Value) -> Result<FilterValue, GraphError> {
+fn parse_string_list(op: &str, v: &Value) -> Result<FieldFilterValue, GraphError> {
     let Value::List(vs) = v else {
         return Err(GraphError::InvalidGqlFilter(format!(
             "{op} requires a list value, got {v}"
@@ -1090,13 +1090,15 @@ fn parse_string_list(op: &str, v: &Value) -> Result<FilterValue, GraphError> {
         })
         .collect::<Result<Vec<_>, _>>()?;
 
-    Ok(FilterValue::Set(Arc::new(strings.into_iter().collect())))
+    Ok(FieldFilterValue::Set(Arc::new(
+        strings.into_iter().collect(),
+    )))
 }
 
 fn translate_node_field_where(
     field: NodeField,
     cond: &NodeFieldCondition,
-) -> Result<(String, FilterValue, FilterOperator), GraphError> {
+) -> Result<(String, FieldFilterValue, FilterOperator), GraphError> {
     use FilterOperator as FO;
     use NodeField::*;
     use NodeFieldCondition::*;
@@ -1109,43 +1111,43 @@ fn translate_node_field_where(
         (NodeId, Ne(v)) => (field_name, parse_node_id_scalar(op, v)?, FO::Ne),
         (NodeId, Gt(v)) => (
             field_name,
-            FilterValue::ID(GID::U64(require_u64_value(op, v)?)),
+            FieldFilterValue::ID(GID::U64(require_u64_value(op, v)?)),
             FO::Gt,
         ),
         (NodeId, Ge(v)) => (
             field_name,
-            FilterValue::ID(GID::U64(require_u64_value(op, v)?)),
+            FieldFilterValue::ID(GID::U64(require_u64_value(op, v)?)),
             FO::Ge,
         ),
         (NodeId, Lt(v)) => (
             field_name,
-            FilterValue::ID(GID::U64(require_u64_value(op, v)?)),
+            FieldFilterValue::ID(GID::U64(require_u64_value(op, v)?)),
             FO::Lt,
         ),
         (NodeId, Le(v)) => (
             field_name,
-            FilterValue::ID(GID::U64(require_u64_value(op, v)?)),
+            FieldFilterValue::ID(GID::U64(require_u64_value(op, v)?)),
             FO::Le,
         ),
 
         (NodeId, StartsWith(v)) => (
             field_name,
-            FilterValue::ID(GID::Str(require_string_value(op, v)?)),
+            FieldFilterValue::ID(GID::Str(require_string_value(op, v)?)),
             FO::StartsWith,
         ),
         (NodeId, EndsWith(v)) => (
             field_name,
-            FilterValue::ID(GID::Str(require_string_value(op, v)?)),
+            FieldFilterValue::ID(GID::Str(require_string_value(op, v)?)),
             FO::EndsWith,
         ),
         (NodeId, Contains(v)) => (
             field_name,
-            FilterValue::ID(GID::Str(require_string_value(op, v)?)),
+            FieldFilterValue::ID(GID::Str(require_string_value(op, v)?)),
             FO::Contains,
         ),
         (NodeId, NotContains(v)) => (
             field_name,
-            FilterValue::ID(GID::Str(require_string_value(op, v)?)),
+            FieldFilterValue::ID(GID::Str(require_string_value(op, v)?)),
             FO::NotContains,
         ),
 
@@ -1154,53 +1156,53 @@ fn translate_node_field_where(
 
         (NodeName, Eq(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::Eq,
         ),
         (NodeName, Ne(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::Ne,
         ),
         (NodeName, Gt(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::Gt,
         ),
         (NodeName, Ge(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::Ge,
         ),
         (NodeName, Lt(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::Lt,
         ),
         (NodeName, Le(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::Le,
         ),
 
         (NodeName, StartsWith(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::StartsWith,
         ),
         (NodeName, EndsWith(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::EndsWith,
         ),
         (NodeName, Contains(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::Contains,
         ),
         (NodeName, NotContains(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::NotContains,
         ),
 
@@ -1209,53 +1211,53 @@ fn translate_node_field_where(
 
         (NodeType, Eq(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::Eq,
         ),
         (NodeType, Ne(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::Ne,
         ),
         (NodeType, Gt(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::Gt,
         ),
         (NodeType, Ge(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::Ge,
         ),
         (NodeType, Lt(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::Lt,
         ),
         (NodeType, Le(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::Le,
         ),
 
         (NodeType, StartsWith(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::StartsWith,
         ),
         (NodeType, EndsWith(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::EndsWith,
         ),
         (NodeType, Contains(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::Contains,
         ),
         (NodeType, NotContains(v)) => (
             field_name,
-            FilterValue::Single(require_string_value(op, v)?),
+            FieldFilterValue::Single(require_string_value(op, v)?),
             FO::NotContains,
         ),
 
@@ -1380,13 +1382,19 @@ impl TryFrom<GqlNodeFilter> for CompositeNodeFilter {
     fn try_from(filter: GqlNodeFilter) -> Result<Self, Self::Error> {
         match filter {
             GqlNodeFilter::Node(node) => {
+                let field = node.field;
                 let (field_name, field_value, operator) =
                     translate_node_field_where(node.field, &node.where_)?;
-                Ok(CompositeNodeFilter::Node(Filter {
+                let filter = Filter {
                     field_name,
                     field_value,
                     operator,
-                }))
+                };
+                Ok(match field {
+                    NodeField::NodeId => CompositeNodeFilter::Id(filter),
+                    NodeField::NodeName => CompositeNodeFilter::Name(filter),
+                    NodeField::NodeType => CompositeNodeFilter::Type(filter),
+                })
             }
             GqlNodeFilter::Property(prop) => {
                 let prop_ref = PropertyRef::Property(prop.name.clone());

raphtory-tests/tests/node_property_filter.rs

@@ -6,7 +6,7 @@ use raphtory::{
         graph::{
             graph::assert_edges_equal,
             views::filter::model::{
-                node_filter::{ops::NodeFilterOps, NodeFilter},
+                node_filter::{ops::NodeFilterOps, NodeFilter, NodeFilterFactory},
                 property_filter::ops::PropertyFilterOps,
                 ComposableFilter, PropertyFilterFactory,
             },
@@ -34,7 +34,8 @@ fn test_node_filter_on_nodes() {
     g.add_node(2, "David", [("band", "Pink Floyd")], None, None)
         .unwrap();
 
-    let filter_expr = NodeFilter::name()
+    let filter_expr = NodeFilter
+        .name()
         .eq("John")
         .and(NodeFilter.property("band").eq("Dead & Company"));
     let filtered_nodes = g.nodes().filter(filter_expr).unwrap();

raphtory/Cargo.toml

@@ -114,7 +114,7 @@ proptest.workspace = true
 proptest-derive.workspace = true
 
 [target.'cfg(target_os = "macos")'.dependencies]
-tikv-jemallocator = "0.6.1"
+tikv-jemallocator = "0.7.0"
 
 [features]
 default = [] # we can't depend on ourselves but we want to share test-utils

raphtory/src/db/api/state/ops/filter.rs

@@ -10,7 +10,7 @@ use crate::{
         graph::{
             create_node_type_filter,
             views::filter::model::{
-                filter::{Filter, FilterValue},
+                filter::{FieldFilterValue, Filter},
                 node_filter::NodeFilter,
                 FilterOperator,
             },
@@ -96,7 +96,7 @@ impl NodeOp for NodeIdFilterOp {
         let op = &self.filter.operator;
         match op {
             FilterOperator::Eq => match &self.filter.field_value {
-                FilterValue::ID(id) => {
+                FieldFilterValue::ID(id) => {
                     let vid = storage.internalise_node(id.as_node_ref());
                     NodeList::List {
                         elems: vid.into_iter().collect(),
@@ -105,7 +105,7 @@ impl NodeOp for NodeIdFilterOp {
                 _ => unreachable!(),
             },
             FilterOperator::IsIn => match &self.filter.field_value {
-                FilterValue::IDSet(ids) => NodeList::List {
+                FieldFilterValue::IDSet(ids) => NodeList::List {
                     elems: ids
                         .iter()
                         .filter_map(|id| storage.internalise_node(id.as_node_ref()))
@@ -153,7 +153,7 @@ impl NodeOp for NodeNameFilterOp {
         let op = &self.filter.operator;
         match op {
             FilterOperator::Eq => match &self.filter.field_value {
-                FilterValue::Single(name) => {
+                FieldFilterValue::Single(name) => {
                     let vid = storage.internalise_node(name.as_node_ref());
                     NodeList::List {
                         elems: vid.into_iter().collect(),
@@ -162,7 +162,7 @@ impl NodeOp for NodeNameFilterOp {
                 _ => unreachable!(),
             },
             FilterOperator::IsIn => match &self.filter.field_value {
-                FilterValue::Set(names) => NodeList::List {
+                FieldFilterValue::Set(names) => NodeList::List {
                     elems: names
                         .iter()
                         .filter_map(|name| storage.internalise_node(name.as_node_ref()))