graphersal 0.1.1

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
123
124
125
126
127
128
129
130

use crate::graph::GraphStorage;
use crate::*;

struct StepOptional<'g, S: GraphStorage + 'g> {
    traversal: AnonymousTraversal<'g, S>,
}

impl<'g, S: GraphStorage + 'g> Clone for StepOptional<'g, S> {
    fn clone(&self) -> Self {
        Self {
            traversal: self.traversal.clone(),
        }
    }
}

impl<'g, S: GraphStorage + 'g> fmt::Display for StepOptional<'g, S> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "optional({})", self.traversal)
    }
}

impl __ {
    /// Emits the results of the child traversal, or the traverser itself when it yields nothing.
    /// Starts an anonymous traversal (`__.optional()`).
    pub fn optional<'g, S: GraphStorage + 'g>(
        traversal: AnonymousTraversal<'g, S>,
    ) -> AnonymousTraversal<'g, S> {
        AnonymousTraversal::new().optional(traversal)
    }
}

impl<'g, S: GraphStorage + 'g> GraphTraversalSource<'g, S> {
    /// Emits the results of the child traversal, or the traverser itself when it yields nothing.
    pub fn optional(self, traversal: AnonymousTraversal<'g, S>) -> Self {
        self.push_step(GraphStep::FlatMap(
            "optional",
            Box::new(StepOptional { traversal }),
        ))
    }
}

impl<'g, S: GraphStorage + 'g> AnonymousTraversal<'g, S> {
    /// Emits the results of the child traversal, or the traverser itself when it yields nothing.
    pub fn optional(self, traversal: AnonymousTraversal<'g, S>) -> Self {
        let step = GraphStep::FlatMap("optional", Box::new(StepOptional { traversal }));
        self.push_step(step)
    }
}

impl<'g, S: GraphStorage + 'g> GraphStepFlatMap<'g, S> for StepOptional<'g, S> {
    #[inline]
    fn process(
        &self,
        context: &mut TraverserContext<'_, S>,
        source: Traverser<S>,
        output: &mut Vec<Traverser<S>>,
    ) -> TraverserResult<()> {
        let x = self.traversal.apply_to(&mut *context, &source)?;
        if x.is_empty() {
            output.push(source);
        } else {
            output.extend(x);
        }
        Ok(())
    }

    fn child_traversals_mut(&mut self) -> Vec<&mut crate::traversal::AnonymousTraversal<'g, S>> {
        vec![&mut self.traversal]
    }

    fn extends_path(&self) -> bool {
        false
    }

    fn analyze_nested_paths(
        &mut self,
        analysis: &crate::traversal::optimizer::path_analysis::PathAnalysis,
        downstream: &crate::traversal::optimizer::path_analysis::PathRequirement,
    ) -> crate::traversal::optimizer::path_analysis::PathRequirement {
        // The child's output continues the path; when the child yields nothing, the incoming
        // traverser passes through unchanged, so what the later steps read is needed on entry too.
        self.traversal
            .analyze_paths(analysis, downstream.clone())
            .union(downstream.clone())
    }

    fn clone_box(&self) -> Box<dyn GraphStepFlatMap<'g, S> + 'g> {
        Box::new(self.clone())
    }
}

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

    #[test]
    fn is_false() {
        test_dual!(
            graph: GraphSource::tinkerpop_modern(),
            rust: |g| g.v("5").optional(__::out(None)).id().to_list(),
            rhai: [
                r#"g.V("5").optional(__.out()).id()"#,
                r#"g.v("5").optional(__.out()).id()"#,
            ],
            assert: |res| assert_eq!(res[0].as_string(), Some("5")),
        );
    }

    #[test]
    fn is_true() {
        test_dual!(
            graph: GraphSource::tinkerpop_modern(),
            rust: |g| g.v("6").optional(__::out(None)).id().to_list(),
            rhai: [
                r#"g.V("6").optional(__.out()).id()"#,
                r#"g.v("6").optional(__.out()).id()"#,
            ],
            assert: |res| assert_eq!(res[0].as_string(), Some("3")),
        );
    }

    #[test]
    fn profile() {
        let graph = GraphSource::tinkerpop_modern();
        let g_lock = graph.read();
        let g = g_lock.traversal();
        let result = g.v("6").optional(__::out(None)).id().profile().unwrap();
        assert!(result.to_string().contains("optional("));
    }
}