redis-graph 0.1.0

API for Redis graph database types.
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

use redis::from_redis_value;
use redis_graph::*;

pub fn check_graph_create_command(r: GraphResultSet) {
    assert!(!r.metadata.is_empty());
}

// Deep check a GraphResultSet
pub fn check_match_query_result(r: GraphResultSet) {
    assert_eq!(r.header, ["n1", "r", "n2.name"]);
    assert_eq!(r.data.len(), 1);
    let data = r.data.get(0).unwrap();
    assert_eq!(data.data.len(), 3);

    match data.get_value("n1") {
        Some(GraphValue::Node(node)) => {
            assert_eq!(node.labels, ["person"]);
            let name: String = from_redis_value(node.properties.get("name").unwrap()).unwrap();
            assert_eq!(name, "Pam");
        }
        _ => assert!(false),
    }

    let n1 = data.get_node("n1").unwrap();
    let name: Option<String> = n1.get_property_option("name");
    assert_eq!(name, Some("Pam".to_string()));

    let not_exists: Option<usize> = n1.get_property_option("not_there");
    assert_eq!(not_exists, None);

    let invalid: Option<usize> = n1.get_property_option("name");
    assert_eq!(invalid, None);

    match data.get_value("r") {
        Some(GraphValue::Relation(rel)) => {
            assert_eq!(rel.rel_type, "works");
            let since: usize = from_redis_value(rel.properties.get("since").unwrap()).unwrap();
            assert_eq!(since, 2010);
        }
        _ => assert!(false),
    }

    let relation = data.get_relation("r").unwrap();
    assert_eq!(relation.rel_type, "works");

    let since: usize = relation.get_property_option("since").unwrap();
    assert_eq!(since, 2010);

    let name: String = data.get_scalar("n2.name").unwrap();
    assert_eq!(name, "Dunder Mifflin");

    assert!(!r.metadata.is_empty());
}

pub fn check_match_scalar_result(res: GraphResultSet) {
    assert_eq!(res.data.len(), 1);
    assert_eq!(res.data.get(0).unwrap().data.len(), 2);
    let driver: String = res.data.get(0).unwrap().get_scalar("r.name").unwrap();
    let team: String = res.data.get(0).unwrap().get_scalar("t.name").unwrap();
    assert_eq!(driver, "Valentino Rossi");
    assert_eq!(team, "Yamaha");
}

pub fn check_query_all_nodes(res: GraphResultSet) {
    for data in res.data.iter() {
        let node = data.get_node("r").unwrap();
        assert!(node.labels.contains(&"Rider".to_string()));
    }
}

pub fn check_unserialize_option(res: GraphResultSet) {
    let born: Vec<Option<usize>> = res.data.iter().map(|v| v.get_scalar("r.born")).collect();
    assert_eq!(born.iter().filter(|v| v.is_none()).count(), 1);
    assert_eq!(born.iter().filter(|v| v.is_some()).count(), 2);
}