orientdb-client 0.6.0

A Rust client for OrientDB™
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

extern crate orientdb_client;

use orientdb_client::{DatabaseType, OrientDB};

#[derive(Debug)]
struct Person {
    name: String,
    surname: String,
}

#[allow(unused_must_use)]
fn main() {
    let client =
        OrientDB::connect(("localhost", 2424)).expect("Failed to connect to OrientDB instance");
    let db = "simple-session";

    let exists = client
        .exist_database(db, "root", "root", DatabaseType::Memory)
        .unwrap();
    if exists {
        client
            .drop_database(db, "root", "root", DatabaseType::Memory)
            .unwrap();
    }

    client
        .create_database(db, "root", "root", DatabaseType::Memory)
        .unwrap();

    let session = client
        .session(db, "admin", "admin")
        .expect("Unable to open a session");

    session
        .command("create class Person extends V")
        .run()
        .unwrap();

    session
        .command("create property Person.name string")
        .run()
        .unwrap();
    session
        .command("create property Person.surname string")
        .run()
        .unwrap();

    let person = Person {
        name: String::from("John"),
        surname: String::from("Reese"),
    };

    session
        .command("insert into Person set name = ? , surname = ?")
        .positional(&[&person.name, &person.surname])
        .run()
        .unwrap();

    for res in session
        .query("select from Person")
        .run()
        .expect("Unable to query the class Foo")
    {
        let r = res.unwrap();
        let person = Person {
            name: r.get("name"),
            surname: r.get("surname"),
        };
        println!("{:?}", person);
    }

    let results = session
        .query("select from Person")
        .run()
        .expect("Unable to query the class Foo")
        .map(|e| {
            e.map(|i| Person {
                name: i.get("name"),
                surname: i.get("surname"),
            })
        })
        .collect::<Result<Vec<Person>, _>>();

    println!("{:?}", results);

    session.close();
}