dgraph_client 0.1.0

A rust client for dgraph.
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
131
132

// Sample adpated from https://docs.dgraph.io/clients/
extern crate dgraph_client;

#[macro_use]
extern crate slog;
extern crate slog_async;
extern crate slog_term;

extern crate serde;
#[macro_use]
extern crate serde_derive;
extern crate serde_json;

extern crate chrono;

mod data;

use slog::Drain;
use dgraph_client::api;
use chrono::prelude::*;
use data::*;
use std::collections::HashMap;

fn main() {
    let decorator = slog_term::TermDecorator::new().build();
    let drain = slog_term::CompactFormat::new(decorator).build().fuse();
    let drain = slog_async::Async::new(drain).build().fuse();

    let log = slog::Logger::root(drain, o!());

    info!(log, "connect to dgraph via grpc at localhost:9080");
    let client = dgraph_client::new_client("localhost:9080");

    // setup

    // Drop all data including schema from the dgraph instance. This is useful
    // for small examples such as this, since it puts dgraph into a clean
    // state.
    info!(log, "drop all");
    let mut op_cleanup = api::Operation::new();
    op_cleanup.drop_all = true;
    client.alter(&op_cleanup).expect("drop schema");

    // Install a schema into dgraph. Accounts have a `name` and a `balance`.
    info!(log, "setup schema");
    let mut op_schema = api::Operation::new();
    op_schema.set_schema(
        r#"
            name: string @index(exact) .
            age: int .
            married: bool .
            loc: geo .
            dob: datetime .
        "#.to_string(),
    );
    client.alter(&op_schema).expect("set schema");

    info!(log, "push data");
    let dob = Utc.ymd(1980, 1, 1).and_hms(23, 0, 0);
    // While setting an object if a struct has a Uid then its properties in the graph are updated
    // else a new node is created.
    // In the example below new nodes for Alice, Bob and Charlie and school are created (since they
    // dont have a Uid).
    let p = Person {
        name: "Alice".to_string(),
        age: Some(26),
        married: Some(true),
        location: Some(Location {
            kind: "Point".to_string(),
            coordinates: vec![1.1f64, 2f64],
        }),
        dob: Some(dob),
        //raw: "raw_bytes".as_bytes().to_vec(),
        friends: Some(vec![
            Person {
                name: "Bob".to_string(),
                age: Some(24),
                ..Default::default()
            },
            Person {
                name: "Charlie".to_string(),
                age: Some(29),
                ..Default::default()
            },
        ]),
        school: Some(vec![
            School {
                name: "Crown Public School".to_string(),
            },
        ]),
        ..Default::default()
    };
    let mut mutation = api::Mutation::new();
    mutation.set_commit_now(true);
    mutation.set_set_json(serde_json::to_vec(&p).expect("valid json"));
    let assigned = client.mutate(&mutation).expect("set data");
    //info!(log, format!("mutation result: {:?}", mutation_txn));

    info!(log, "query");
    let mut req = ::api::Request::new();

    // Assigned uids for nodes which were created would be returned in the resp.AssignedUids map.
    req.vars = [("$id".to_string(), assigned.uids["blank-0"].clone())]
        .iter()
        .cloned()
        .collect::<HashMap<String, String>>();
    req.query = r#"query Me($id: string){
        me(func: uid($id)) {
            name
            dob
            age
            loc
            raw_bytes
            married
            friend @filter(eq(name, "Bob")){
                name
                age
            }
            school {
                name
            }
        }
    }"#.to_string();
    let resp = client.query(&req).expect("query");
    println!("{:?}", resp);
    let root: Root = serde_json::from_slice(&resp.json).expect("parsing");
    // output: Root { me: [Person { name: "Alice", age: Some(26), dob: Some(1980-01-01T23:00:00Z), married: Some(true), raw: None, friends: Some([Person { name: "Bob", age: Some(24), dob: None, married: None, raw: None, friends: None, location: None, school: None }]), location: Some(Location { kind: "Point", coordinates: [1.1, 2.0] }), school: Some([School { name: "Crown Public School" }]) }] }
    println!("{:?}", root);
    //info!(log, "resp", "root" => root);
    // info!(log, "close client");
    // client.close();
}