graphersal 0.1.0

In-memory graph traversal engine modelled on Apache TinkerPop Gremlin, with a Rhai DSL, optimizer and GraphSON/GraphML I/O
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

//! `merge()`: the union of two lists, or two maps merged.

use super::list_function::{ListArg, ListFunction, list_function_builders, list_function_step};
use crate::graph::GraphStorage;
use crate::*;

list_function_builders!(
    ListFunction::Merge,
    merge,
    merge_traversal,
    "`merge(list | map)` (TinkerPop `MergeStep`): for a list, the union of the list a traverser \
     holds and `list`, each element at most once, incoming elements first (`[\"a\", null, \"b\"]` \
     and `[\"a\", \"c\"]` give `[\"a\", null, \"b\", \"c\"]`). For a map (`project()`, \
     `elementMap()`, a map constant), the incoming entries with the argument's entries added or \
     overriding them; the argument must then be a map, and a map argument for a list is an error.",
    "let names = g.v(None).values(\"name\").fold().merge(vec![\"marko\", \"dave\"]).next().unwrap().unwrap();\n\
     assert_eq!(names.as_array().map(|a| a.len()), Some(7));"
);

#[cfg(test)]
mod tests {
    use super::*;

    fn map(entries: &[(&str, &str)]) -> ElementProperty {
        ElementProperty::Object(Box::new(
            entries
                .iter()
                .map(|(k, v)| ((*k), ElementProperty::from(*v)))
                .collect(),
        ))
    }

    #[test]
    fn list_union() {
        test_dual!(
            graph: GraphSource::tinkerpop_modern(),
            rust: |g| g
                .inject(vec![ElementProperty::Array(vec![
                    ElementProperty::from("a"),
                    ElementProperty::Null,
                    ElementProperty::from("b"),
                ])])
                .merge(vec!["a", "c"])
                .to_list(),
            rhai: [r#"g.inject(["a", (), "b"]).merge(["a", "c"])"#],
            assert: |res| assert_eq!(
                res,
                &[ElementProperty::Array(vec![
                    ElementProperty::from("a"),
                    ElementProperty::Null,
                    ElementProperty::from("b"),
                    ElementProperty::from("c"),
                ])]
            ),
        );
    }

    #[test]
    fn map_merge_overrides_with_the_argument() {
        test_dual!(
            graph: GraphSource::tinkerpop_modern(),
            rust: |g| g
                .v("1")
                .project(vec!["name", "kind"])
                .by("name")
                .by(__::constant("person"))
                .merge(map(&[("kind", "friend"), ("other", "blueprint")]))
                .to_list(),
            rhai: [
                r#"g.V("1").project("name", "kind").by("name").by(__.constant("person")).merge(#{kind: "friend", other: "blueprint"})"#,
            ],
            assert: |res| assert_eq!(
                res,
                &[map(&[("name", "marko"), ("kind", "friend"), ("other", "blueprint")])]
            ),
        );
        test_dual!(
            graph: GraphSource::tinkerpop_modern(),
            rust: |g| g
                .v("1")
                .element_map(None)
                .merge_traversal(__::v("3").element_map(None))
                .to_list(),
            rhai: [
                r#"g.V("1").elementMap().merge(__.V("3").elementMap())"#,
            ],
            assert: |res| {
                let m = res[0].as_object().expect("a map");
                assert_eq!(m.get("id"), Some(&ElementProperty::from("3")));
                assert_eq!(m.get("name"), Some(&ElementProperty::from("lop")));
                assert_eq!(m.get("age"), Some(&ElementProperty::from(29)));
                assert_eq!(m.get("lang"), Some(&ElementProperty::from("java")));
            },
        );
    }

    #[test]
    fn list_and_map_do_not_mix() {
        test_dual_err!(
            graph: GraphSource::tinkerpop_modern(),
            rust: |g| g.v(None).fold().merge(map(&[("k", "v")])).to_list(),
            rhai: [r#"g.V().fold().merge(#{k: "v"})"#],
            assert: |err| assert!(err.contains("takes a list as its argument, but got map"), "{err}"),
        );
        test_dual_err!(
            graph: GraphSource::tinkerpop_modern(),
            rust: |g| g
                .v(None)
                .element_map(None)
                .merge_traversal(__::constant("a"))
                .to_list(),
            rhai: [r#"g.V().elementMap().merge(__.constant("a"))"#],
            assert: |err| assert!(err.contains("takes a map as its traversal argument, but got string"), "{err}"),
        );
        test_dual_err!(
            graph: GraphSource::tinkerpop_modern(),
            rust: |g| g.v(None).values("name").merge(vec!["a"]).to_list(),
            rhai: [r#"g.V().values("name").merge(["a"])"#],
            assert: |err| assert!(err.contains("takes a list or map as its incoming value, but got string"), "{err}"),
        );
    }
}