rocksgraph 0.1.0

A Gremlin-inspired property graph query engine written in Rust, backed by RocksDB
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

// Physical tests: choose()
use crate::engine::volcano::steps::traits::CoreStep;
use crate::{
    engine::{
        context::NoopCtx,
        traverser::Traverser,
        volcano::{
            builder::PhysicalPlan,
            steps::{
                choose::ChooseStep,
                scalar_filter::ScalarFilterStep,
                traits::{BufferedStep, StepRef},
                vec_source::VecSourceStep,
            },
        },
    },
    types::gvalue::{GValue, Primitive, PrimitivePredicate},
};
use smallvec::smallvec;
use std::rc::Rc;

fn t(v: i64) -> Rc<Traverser> {
    Traverser::new_rc(GValue::Scalar(Primitive::Int64(v)))
}

fn eq_plan(v: i64) -> PhysicalPlan {
    let src = BufferedStep::new(VecSourceStep::empty());
    let mut f = ScalarFilterStep::new(PrimitivePredicate::Eq(Primitive::Int64(v)));
    f.add_upper(src.clone() as StepRef);
    PhysicalPlan { source: src.clone(), tail: BufferedStep::new(f) as StepRef }
}

fn identity_plan() -> PhysicalPlan {
    let src = BufferedStep::new(VecSourceStep::empty());
    PhysicalPlan { source: src.clone(), tail: src.clone() as StepRef }
}

#[test]
fn test_choose_true_branch() {
    let src = BufferedStep::new(VecSourceStep::empty());
    src.inner.borrow_mut().core.inject(smallvec![t(42)]);
    let mut step = ChooseStep::new(eq_plan(42), identity_plan(), None);
    step.add_upper(src.clone() as StepRef);
    let mut ctx = NoopCtx;
    assert_eq!(step.produce(&mut ctx).unwrap().unwrap()[0].value, GValue::Scalar(Primitive::Int64(42)));
    assert!(step.produce(&mut ctx).unwrap().is_none());
}

#[test]
fn test_choose_pass_through() {
    let src = BufferedStep::new(VecSourceStep::empty());
    src.inner.borrow_mut().core.inject(smallvec![t(99)]);
    let mut step = ChooseStep::new(eq_plan(42), identity_plan(), None);
    step.add_upper(src.clone() as StepRef);
    let mut ctx = NoopCtx;
    assert_eq!(step.produce(&mut ctx).unwrap().unwrap()[0].value, GValue::Scalar(Primitive::Int64(99)));
}

#[test]
fn test_choose_false_branch() {
    let src = BufferedStep::new(VecSourceStep::empty());
    src.inner.borrow_mut().core.inject(smallvec![t(99)]);
    let mut step = ChooseStep::new(eq_plan(42), identity_plan(), Some(identity_plan()));
    step.add_upper(src.clone() as StepRef);
    let mut ctx = NoopCtx;
    assert_eq!(step.produce(&mut ctx).unwrap().unwrap()[0].value, GValue::Scalar(Primitive::Int64(99)));
}

#[test]
fn test_choose_no_upstream() {
    let mut step = ChooseStep::new(eq_plan(42), identity_plan(), None);
    let mut ctx = NoopCtx;
    assert!(step.produce(&mut ctx).unwrap().is_none());
}

#[test]
fn test_choose_reset() {
    let src = BufferedStep::new(VecSourceStep::empty());
    src.inner.borrow_mut().core.inject(smallvec![t(42)]);
    let mut step = ChooseStep::new(eq_plan(42), identity_plan(), None);
    step.add_upper(src.clone() as StepRef);
    let mut ctx = NoopCtx;
    assert!(step.produce(&mut ctx).unwrap().is_some());
    step.reset();
    src.inner.borrow_mut().core.inject(smallvec![t(42)]);
    assert!(step.produce(&mut ctx).unwrap().is_some());
}