redisgraphio 0.2.0

Client library for working with redis graph
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

use redis::{aio::ConnectionLike, RedisFuture, cmd};

use crate::{types::GraphQuery, FromGraphValue, GraphResponse, query};


/// Implements redis graph related commands for an asynchronous connection
pub trait AsyncGraphCommands: ConnectionLike + Send + Sized {
    /// Send a graph query asynchronously
    fn graph_query<'a, Q, RT>(
        &'a mut self,
        graph: &'a str,
        query: Q,
    ) -> RedisFuture<GraphResponse<RT>>
    where 
        Q: Into<GraphQuery> + Send + 'a,
        RT: FromGraphValue
    {
        Box::pin(async move {
            let query = query.into();
            cmd(query.read_type())
                .arg(graph)
                .arg(query.construct_query())
                .arg("--compact")
                .query_async(self)
                .await
        })
    }

    /// Send a graph query asynchronously and ignore the result data
    fn graph_query_void<'a, Q>(
        &'a mut self,
        graph: &'a str,
        query: Q,
    ) -> RedisFuture<GraphResponse<()>>
    where 
        Q: Into<GraphQuery> + Send + 'a,
    {
        Box::pin(async move {
            let query = query.into();
            cmd(query.read_type())
                .arg(graph)
                .arg(query.construct_query())
                .arg("--compact")
                .query_async(self)
                .await
        })
    }

    /// Returns a vector where the index is a label id and the value at that index is the corresponding label name
    fn labels<'a>(&'a mut self, graph: &'a str) -> RedisFuture<'a, Vec<String>> {
        Box::pin(async move {
            let data: Vec<Vec<String>> = self.graph_query(graph, query!("CALL db.labels()")).await?.data;
            Ok(data.into_iter().map(|mut vec| vec.remove(0)).collect())
        })
    }

    /// Returns a vector where the index is a property key id and the value at that index is the corresponding property key name
    fn property_keys<'a>(&'a mut self, graph: &'a str) -> RedisFuture<'a, Vec<String>> {
        Box::pin(async move {
            let data: Vec<Vec<String>> = self.graph_query(graph, query!("CALL db.propertyKeys()")).await?.data;
            Ok(data.into_iter().map(|mut vec| vec.remove(0)).collect())
        })
    }

    /// Returns a vector where the index is a relationship id and the value at that index is the corresponding relationship name
    fn relationship_types<'a>(&'a mut self, graph: &'a str) -> RedisFuture<'a, Vec<String>> {
        Box::pin(async move {
            let data: Vec<Vec<String>> = self.graph_query(graph, query!("CALL db.relationshipTypes()")).await?.data;
            Ok(data.into_iter().map(|mut vec| vec.remove(0)).collect())
        })
    }
}

impl<T> AsyncGraphCommands for T where T: Send + ConnectionLike {}