klub_stores 0.0.2

Klub database interface
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

use crate::dbs::controller::ModelParams;
use neo4rs::Graph;
use neo4rs::*;
use std::sync::Arc;

#[derive(Clone)]
pub struct Neo4J {
    pub client: Option<Arc<Graph>>,
    pub enable_logging: bool,
}

pub struct NodeWithRelsResult {
    pub node_one: Option<Node>,
    pub rel: Option<Relation>,
    pub node_two: Option<Node>,
}

impl Neo4J {
    pub fn new() -> Self {
        Self {
            client: None,
            enable_logging: true,
        }
    }
    pub async fn connect(&mut self) -> Result<Graph> {
        let uri = "localhost:7687";
        let user = "neo4j";
        let pass = "test";
        Graph::new(&uri, user, pass).await
    }

    fn log_query(&self, query_str: &String) {
        println!("=================================");
        println!("=================================");
        println!("Executing Query - find_by_id");
        println!("{:?}", query_str);
        println!("=================================");
        println!("=================================");
    }
    pub async fn find_node_by_id(
        &self,
        graph: Arc<&Graph>,
        model_params: ModelParams,
        id: &str,
    ) -> Option<Node> {
        let model_name = model_params.model_name;
        let model_alias = model_params.model_alias;
        let graph = graph.clone();
        let cypher_query_str = format_args!(
            "MATCH ({model_alias}:{model_name}{{id: '{id}'}})
            RETURN {model_alias}",
            model_alias = model_alias,
            model_name = model_name,
            id = id
        )
        .to_string();

        if self.enable_logging == true {
            &self.log_query(&cypher_query_str);
        }
        let query_str = &cypher_query_str[..];
        let mut row_stream = graph.execute(query(query_str)).await.unwrap();
        let mut result_node: Option<Node> = None;
        while let Ok(Some(row)) = row_stream.next().await {
            result_node = Some(row.get(model_alias).unwrap());
        }
        result_node
    }

    pub async fn find_nodes_with_rels(
        &self,
        graph: Arc<&Graph>,
        id: &str,
        node_one_model_params: ModelParams,
        node_two_model_params: ModelParams,
        rel_model_params: ModelParams,
    ) -> Option<Vec<NodeWithRelsResult>> {
        let node_one_model_name = node_one_model_params.model_name;
        let node_one_model_alias = node_one_model_params.model_alias;
        let node_two_model_name = node_two_model_params.model_name;
        let node_two_model_alias = node_two_model_params.model_alias;
        let rel_model_name = rel_model_params.model_name;
        let rel_model_alias = rel_model_params.model_alias;

        let graph = graph.clone();

        let cypher_query_str = format_args!(
            "MATCH ({node_one_model_alias}:{node_one_model_name}{{id: '{id}'}})-[{rel_model_alias}:{rel_model_name}]-({node_two_model_alias}:{node_two_model_name})
            RETURN {node_one_model_alias}, {rel_model_alias}, {node_two_model_alias}",
            node_one_model_alias = node_one_model_alias,
            node_one_model_name = node_one_model_name,
            node_two_model_alias = node_two_model_alias,
            node_two_model_name = node_two_model_name,
            rel_model_alias = rel_model_alias,
            rel_model_name = rel_model_name,
            id = id
        )
        .to_string();

        if self.enable_logging == true {
            &self.log_query(&cypher_query_str);
        }

        let query_str = &cypher_query_str[..];
        let mut row_stream = graph.execute(query(query_str)).await.unwrap();
        let mut results = vec![];
        while let Ok(Some(row)) = row_stream.next().await {
            let result_node_one: Option<Node> = Some(row.get(node_one_model_alias).unwrap());
            let result_rel: Option<Relation> = Some(row.get(rel_model_alias).unwrap());
            let result_node_two: Option<Node> = Some(row.get(node_two_model_alias).unwrap());
            let row = NodeWithRelsResult {
                node_one: result_node_one,
                rel: result_rel,
                node_two: result_node_two,
            };
            results.push(row);
        }
        Some(results)
    }
}