indradb 0.12.1

A graph database server
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
131
132
133
134
135
136
137
138
139
140
141
142

#![allow(unreachable_code)]
// Above ignore is there because otherwise the macro is noisy

use super::converters;
use indradb::{Error, Transaction};
use common::ProxyTransaction;
use serde_json::Value as JsonValue;

pub fn create_vertex(
    trans: &ProxyTransaction,
    t: converters::Type,
) -> Result<converters::Uuid, Error> {
    Ok(converters::Uuid::new(trans.create_vertex(&t.0)?))
}

pub fn get_vertices(
    trans: &ProxyTransaction,
    q: converters::VertexQuery,
) -> Result<Vec<converters::Vertex>, Error> {
    Ok(trans
        .get_vertices(&q.0)?
        .into_iter()
        .map(converters::Vertex::new)
        .collect())
}

pub fn delete_vertices(trans: &ProxyTransaction, q: converters::VertexQuery) -> Result<(), Error> {
    trans.delete_vertices(&q.0)
}

pub fn get_vertex_count(trans: &ProxyTransaction, _: ()) -> Result<u64, Error> {
    trans.get_vertex_count()
}

pub fn create_edge(trans: &ProxyTransaction, key: converters::EdgeKey) -> Result<(), Error> {
    trans.create_edge(&key.0)?;
    Ok(())
}

pub fn get_edges(
    trans: &ProxyTransaction,
    q: converters::EdgeQuery,
) -> Result<Vec<converters::Edge>, Error> {
    Ok(trans
        .get_edges(&q.0)?
        .into_iter()
        .map(converters::Edge::new)
        .collect())
}

pub fn delete_edges(trans: &ProxyTransaction, q: converters::EdgeQuery) -> Result<(), Error> {
    trans.delete_edges(&q.0)?;
    Ok(())
}

pub fn get_edge_count(
    trans: &ProxyTransaction,
    (id, type_filter, direction): (
        converters::Uuid,
        Option<converters::Type>,
        converters::EdgeDirection,
    ),
) -> Result<u64, Error> {
    Ok(trans.get_edge_count(id.0, type_filter.as_ref().map(|t| &t.0), direction.0)?)
}

pub fn get_global_metadata(
    trans: &ProxyTransaction,
    key: String,
) -> Result<converters::JsonValue, Error> {
    Ok(converters::JsonValue::new(
        trans
            .get_global_metadata(&key)?
            .unwrap_or_else(|| JsonValue::Null),
    ))
}

pub fn set_global_metadata(
    trans: &ProxyTransaction,
    (key, value): (String, converters::JsonValue),
) -> Result<(), Error> {
    trans.set_global_metadata(&key, &value.0)?;
    Ok(())
}

pub fn delete_global_metadata(trans: &ProxyTransaction, key: String) -> Result<(), Error> {
    trans.delete_global_metadata(&key)?;
    Ok(())
}

pub fn get_vertex_metadata(
    trans: &ProxyTransaction,
    (q, key): (converters::VertexQuery, String),
) -> Result<Vec<converters::VertexMetadata>, Error> {
    Ok(trans
        .get_vertex_metadata(&q.0, &key)?
        .into_iter()
        .map(converters::VertexMetadata::new)
        .collect())
}

pub fn set_vertex_metadata(
    trans: &ProxyTransaction,
    (q, key, value): (converters::VertexQuery, String, converters::JsonValue),
) -> Result<(), Error> {
    Ok(trans.set_vertex_metadata(&q.0, &key, &value.0)?)
}

pub fn delete_vertex_metadata(
    trans: &ProxyTransaction,
    (q, key): (converters::VertexQuery, String),
) -> Result<(), Error> {
    trans.delete_vertex_metadata(&q.0, &key)?;
    Ok(())
}

pub fn get_edge_metadata(
    trans: &ProxyTransaction,
    (q, key): (converters::EdgeQuery, String),
) -> Result<Vec<converters::EdgeMetadata>, Error> {
    Ok(trans
        .get_edge_metadata(&q.0, &key)?
        .into_iter()
        .map(converters::EdgeMetadata::new)
        .collect())
}

pub fn set_edge_metadata(
    trans: &ProxyTransaction,
    (q, key, value): (converters::EdgeQuery, String, converters::JsonValue),
) -> Result<(), Error> {
    trans.set_edge_metadata(&q.0, &key, &value.0)?;
    Ok(())
}

pub fn delete_edge_metadata(
    trans: &ProxyTransaction,
    (q, key): (converters::EdgeQuery, String),
) -> Result<(), Error> {
    trans.delete_edge_metadata(&q.0, &key)?;
    Ok(())
}