@@ -497,31 +497,8 @@ fn apply_expect(view: &ResponseView, expect: &QueryExpect, label: &str) {
         for (field, expected) in &ne.filters {
             let expected = expected.clone();
             let field_name = field.clone();
-            view.assert_filter(entity, field, move |n| match &expected {
-                serde_json::Value::Object(m) if m.contains_key("starts_with") => {
-                    let prefix = m["starts_with"].as_str().unwrap();
-                    n.prop_str(&field_name)
-                        .is_some_and(|v| v.starts_with(prefix))
-                }
-                serde_json::Value::Object(m) if m.contains_key("contains") => {
-                    let sub = m["contains"].as_str().unwrap();
-                    n.prop_str(&field_name).is_some_and(|v| v.contains(sub))
-                }
-                serde_json::Value::Object(m) if m.contains_key("ends_with") => {
-                    let suffix = m["ends_with"].as_str().unwrap();
-                    n.prop_str(&field_name).is_some_and(|v| v.ends_with(suffix))
-                }
-                serde_json::Value::Object(m) if m.contains_key("in") => {
-                    let vals = m["in"].as_array().unwrap();
-                    n.prop(&field_name).is_some_and(|p| vals.contains(p))
-                }
-                serde_json::Value::Object(m) if m.contains_key("gte") => {
-                    let threshold = m["gte"].as_i64().unwrap();
-                    n.prop_i64(&field_name)
-                        .or_else(|| n.prop_str(&field_name).and_then(|s| s.parse().ok()))
-                        .is_some_and(|v| v >= threshold)
-                }
-                _ => n.prop(&field_name) == Some(&expected),
+            view.assert_filter(entity, field, move |n| {
+                eval_filter_predicate(n, &field_name, &expected)
             });
         }
     }
@@ -646,6 +623,79 @@ fn apply_expect(view: &ResponseView, expect: &QueryExpect, label: &str) {
     }
 }
 
+fn eval_filter_predicate(
+    n: &query_engine::formatters::GraphNode,
+    field: &str,
+    expected: &serde_json::Value,
+) -> bool {
+    match expected {
+        serde_json::Value::Object(m) if m.contains_key("starts_with") => n
+            .prop_str(field)
+            .is_some_and(|v| v.starts_with(m["starts_with"].as_str().unwrap())),
+        serde_json::Value::Object(m) if m.contains_key("contains") => n
+            .prop_str(field)
+            .is_some_and(|v| v.contains(m["contains"].as_str().unwrap())),
+        serde_json::Value::Object(m) if m.contains_key("ends_with") => n
+            .prop_str(field)
+            .is_some_and(|v| v.ends_with(m["ends_with"].as_str().unwrap())),
+        serde_json::Value::Object(m) if m.contains_key("in") => {
+            let vals = m["in"].as_array().unwrap();
+            n.prop(field).is_some_and(|p| vals.contains(p))
+        }
+        serde_json::Value::Object(m)
+            if m.get("is_null") == Some(&serde_json::Value::Bool(true)) =>
+        {
+            !n.properties.is_empty() && !n.has_prop(field)
+        }
+        serde_json::Value::Object(m)
+            if m.get("is_not_null") == Some(&serde_json::Value::Bool(true)) =>
+        {
+            n.has_prop(field)
+        }
+        serde_json::Value::Object(m) if m.contains_key("gte") => {
+            let threshold = &m["gte"];
+            if let Some(t) = threshold.as_i64() {
+                n.prop_i64(field)
+                    .or_else(|| n.prop_str(field).and_then(|s| s.parse().ok()))
+                    .is_some_and(|v| v >= t)
+            } else {
+                let t = threshold.as_str().unwrap();
+                n.prop_str(field).is_some_and(|v| v >= t)
+            }
+        }
+        serde_json::Value::Object(m) if m.contains_key("lte") => {
+            let t = m["lte"].as_str().unwrap();
+            n.prop_str(field).is_some_and(|v| v <= t)
+        }
+        serde_json::Value::Object(m) if m.contains_key("lt") => {
+            let t = m["lt"].as_str().unwrap();
+            n.prop_str(field).is_some_and(|v| v < t)
+        }
+        serde_json::Value::Object(m) if m.contains_key("eq") => {
+            let val = &m["eq"];
+            n.prop(field) == Some(val)
+                || match val {
+                    serde_json::Value::Number(num) => {
+                        n.prop_str(field).is_some_and(|s| s == num.to_string())
+                    }
+                    serde_json::Value::String(s) => n.prop_str(field) == Some(s.as_str()),
+                    _ => false,
+                }
+        }
+        // Compound filter: all sub-predicates must pass
+        serde_json::Value::Object(m) if m.len() > 1 => m.iter().all(|(op, val)| {
+            let sub =
+                serde_json::Value::Object(std::iter::once((op.clone(), val.clone())).collect());
+            eval_filter_predicate(n, field, &sub)
+        }),
+        serde_json::Value::Object(m) if m.len() == 1 => {
+            let op = m.keys().next().unwrap();
+            panic!("unsupported filter operator '{op}' on field '{field}'")
+        }
+        _ => n.prop(field) == Some(expected),
+    }
+}
+
 fn assert_property(
     node: &dyn NodeExt,
     prop: &str,
 
@@ -0,0 +1,21 @@
+# source: crates/integration-tests/tests/server/data_correctness/search.rs::search_boolean_columns_have_correct_values
+description: Boolean columns serialize as true/false values
+
+query:
+  json: |
+    {
+      "query_type": "traversal",
+      "nodes": [{"id": "n", "entity": "Note", "id_range": {"start": 1, "end": 10000},
+                 "columns": ["note", "confidential", "internal"],
+                 "node_ids": [3000, 3001]}],
+      "limit": 10
+    }
+
+expect:
+  node_count: 2
+  nodes:
+    Note:
+      ids: [3000, 3001]
+      rows:
+        - { id: 3000, confidential: false, internal: false }
+        - { id: 3001, confidential: true, internal: false }
@@ -0,0 +1,23 @@
+# source: crates/integration-tests/tests/server/data_correctness/search.rs::search_combined_filter_node_ids_order_by
+description: Filter, node_ids, and order_by combine correctly
+
+query:
+  json: |
+    {
+      "query_type": "traversal",
+      "nodes": [{"id": "u", "entity": "User", "id_range": {"start": 1, "end": 10000},
+                 "columns": ["username", "state"],
+                 "node_ids": [1, 2, 3, 5],
+                 "filters": {"state": "active"}}],
+      "order_by": "-u.id",
+      "limit": 10
+    }
+
+expect:
+  node_count: 3
+  nodes:
+    User:
+      order: [3, 2, 1]
+      absent: [5]
+      filters:
+        state: active
@@ -0,0 +1,19 @@
+# source: crates/integration-tests/tests/server/data_correctness/search.rs::search_datetime_columns_serialize_as_strings
+description: DateTime columns serialize as strings containing the date components
+
+query:
+  json: |
+    {
+      "query_type": "traversal",
+      "nodes": [{"id": "n", "entity": "Note", "id_range": {"start": 1, "end": 10000},
+                 "columns": ["note", "created_at"],
+                 "node_ids": [3000, 3001]}],
+      "limit": 10
+    }
+
+expect:
+  node_count: 2
+  nodes:
+    Note:
+      ids: [3000, 3001]
+      prop_present: [created_at]
@@ -0,0 +1,16 @@
+# source: crates/integration-tests/tests/server/data_correctness/search.rs::search_default_columns_include_full_path
+description: Default columns include full_path without explicit column selection
+
+query:
+  json: |
+    {
+      "query_type": "traversal",
+      "nodes": [{"id": "g", "entity": "Group", "id_range": {"start": 1, "end": 10000}}],
+      "limit": 10
+    }
+
+expect:
+  node_count: 5
+  nodes:
+    Group:
+      prop_present: [full_path]
@@ -0,0 +1,23 @@
+# source: crates/integration-tests/tests/server/data_correctness/search.rs::search_definition_content_selective
+description: Definition content contains filter returns matching definitions
+
+query:
+  json: |
+    {
+      "query_type": "traversal",
+      "nodes": [{"id": "d", "entity": "Definition",
+               "node_ids": [12000, 12001, 12002, 12100, 12102],
+               "columns": ["name", "file_path", "content"],
+               "filters": {
+                   "content": {"contains": "normalize"}
+               }}],
+      "limit": 10
+    }
+
+expect:
+  node_count: 1
+  nodes:
+    Definition:
+      ids: [12000]
+      filters:
+        content: { contains: normalize }
@@ -0,0 +1,27 @@
+# source: crates/integration-tests/tests/server/data_correctness/search.rs::search_file_content_combined_with_physical
+description: File content virtual filter combined with physical path filter
+
+query:
+  json: |
+    {
+      "query_type": "traversal",
+      "nodes": [{"id": "f", "entity": "File",
+               "node_ids": [13000, 13001, 13002, 13003, 13004],
+               "columns": ["path", "project_id", "content"],
+               "filters": {
+                   "project_id": {"eq": 1000},
+                   "path": {"starts_with": "src/"},
+                   "content": {"contains": "ClickHouse"}
+               }}],
+      "limit": 10
+    }
+
+expect:
+  node_count: 1
+  nodes:
+    File:
+      ids: [13001]
+      filters:
+        path: { starts_with: "src/" }
+        project_id: { eq: 1000 }
+        content: { contains: ClickHouse }
@@ -0,0 +1,26 @@
+# source: crates/integration-tests/tests/server/data_correctness/search.rs::search_file_content_contains_selective
+description: File content contains filter returns matching files
+
+query:
+  json: |
+    {
+      "query_type": "traversal",
+      "nodes": [{"id": "f", "entity": "File",
+               "node_ids": [13000, 13001, 13002, 13003, 13004],
+               "columns": ["path", "project_id", "content"],
+               "filters": {
+                   "project_id": {"eq": 1000},
+                   "content": {"contains": "ClickHouse"}
+               }}],
+      "order_by": "f.id",
+      "limit": 10
+    }
+
+expect:
+  node_count: 2
+  nodes:
+    File:
+      order: [13001, 13002]
+      filters:
+        project_id: { eq: 1000 }
+        content: { contains: ClickHouse }
@@ -0,0 +1,25 @@
+# source: crates/integration-tests/tests/server/data_correctness/search.rs::search_file_content_ends_with
+description: File content ends_with filter matches suffix
+
+query:
+  json: |
+    {
+      "query_type": "traversal",
+      "nodes": [{"id": "f", "entity": "File",
+               "node_ids": [13000, 13001, 13002, 13003, 13004],
+               "columns": ["path", "project_id", "content"],
+               "filters": {
+                   "project_id": {"eq": 1000},
+                   "content": {"ends_with": "crate."}
+               }}],
+      "limit": 10
+    }
+
+expect:
+  node_count: 1
+  nodes:
+    File:
+      ids: [13002]
+      filters:
+        project_id: { eq: 1000 }
+        content: { ends_with: "crate." }
@@ -0,0 +1,25 @@
+# source: crates/integration-tests/tests/server/data_correctness/search.rs::search_file_content_eq_exact
+description: File content eq filter matches exact content
+
+query:
+  json: |
+    {
+      "query_type": "traversal",
+      "nodes": [{"id": "f", "entity": "File",
+               "node_ids": [13000, 13001, 13002, 13003, 13004],
+               "columns": ["path", "project_id", "content"],
+               "filters": {
+                   "project_id": {"eq": 1000},
+                   "content": {"eq": "0.91.0"}
+               }}],
+      "limit": 10
+    }
+
+expect:
+  node_count: 1
+  nodes:
+    File:
+      ids: [13004]
+      filters:
+        project_id: { eq: 1000 }
+        content: { eq: "0.91.0" }