cypherlite-query 1.2.2

Cypher query engine with parser, planner, and executor for CypherLite
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

// NodeScanOp: scans all nodes or nodes by label

use crate::executor::{Record, Value};
use cypherlite_storage::StorageEngine;

/// Scan nodes from the engine, optionally filtered by label.
/// Each node produces a Record with the variable bound to Value::Node(node_id).
pub fn execute_node_scan(
    variable: &str,
    label_id: Option<u32>,
    engine: &StorageEngine,
) -> Vec<Record> {
    let nodes = match label_id {
        Some(lid) => engine.scan_nodes_by_label(lid),
        None => engine.scan_nodes(),
    };

    nodes
        .into_iter()
        .map(|node| {
            let mut record = Record::new();
            record.insert(variable.to_string(), Value::Node(node.node_id));
            record
        })
        .collect()
}

#[cfg(test)]
mod tests {
    use super::*;
    use cypherlite_core::{DatabaseConfig, LabelRegistry, SyncMode};
    use tempfile::tempdir;

    fn test_engine(dir: &std::path::Path) -> StorageEngine {
        let config = DatabaseConfig {
            path: dir.join("test.cyl"),
            wal_sync_mode: SyncMode::Normal,
            ..Default::default()
        };
        StorageEngine::open(config).expect("open")
    }

    // EXEC-T001: NodeScan with label filter
    #[test]
    fn test_node_scan_with_label_filter() {
        let dir = tempdir().expect("tempdir");
        let mut engine = test_engine(dir.path());

        let person_label = engine.get_or_create_label("Person");
        let company_label = engine.get_or_create_label("Company");

        engine.create_node(vec![person_label], vec![]);
        engine.create_node(vec![person_label], vec![]);
        engine.create_node(vec![company_label], vec![]);

        let records = execute_node_scan("n", Some(person_label), &engine);
        assert_eq!(records.len(), 2);

        for record in &records {
            assert!(record.contains_key("n"));
            assert!(matches!(record.get("n"), Some(Value::Node(_))));
        }
    }

    #[test]
    fn test_node_scan_all_nodes() {
        let dir = tempdir().expect("tempdir");
        let mut engine = test_engine(dir.path());

        engine.create_node(vec![0], vec![]);
        engine.create_node(vec![1], vec![]);
        engine.create_node(vec![2], vec![]);

        let records = execute_node_scan("n", None, &engine);
        assert_eq!(records.len(), 3);
    }

    #[test]
    fn test_node_scan_empty_database() {
        let dir = tempdir().expect("tempdir");
        let engine = test_engine(dir.path());

        let records = execute_node_scan("n", Some(0), &engine);
        assert!(records.is_empty());
    }
}