neo4j-cli 0.1.0

A CLI to interact with Neo4j graph database written in Rust
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
143
144
145
146
147
148

use clap::Parser;
use neo4j_cli::{Cli, Commands};
use neo4rs::{query, Graph};
use rustyline::DefaultEditor;
use std::error::Error;
use std::fmt;
use std::sync::Arc;

static mut GLOBAL_GRAPH: Option<Arc<Graph>> = None;

#[tokio::main]
async fn main() {
    let args = Cli::parse();

    match &args.command {
        Commands::Connect(obj) => {
            if let Err(err) = connect(&obj.uri, &obj.username, &obj.password).await {
                println!("Failed to connect to Neo4j database: {:?}", err);
                return;
            }
        }
    }
}

#[derive(Debug)]
enum CustomError {
    Neo4rsError(neo4rs::Error),
    ReadlineError(rustyline::error::ReadlineError),
}

impl Error for CustomError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            CustomError::Neo4rsError(err) => Some(err),
            CustomError::ReadlineError(err) => Some(err),
        }
    }
}

impl fmt::Display for CustomError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            CustomError::Neo4rsError(err) => write!(f, "Neo4rs Error: {}", err),
            CustomError::ReadlineError(err) => write!(f, "Readline Error: {}", err),
        }
    }
}

async fn connect(
    uri: &str,
    username: &str,
    password: &str,
) -> Result<(), Box<dyn std::error::Error>> {
    let graph = Arc::new(Graph::new(uri, username, password).await?);
    unsafe {
        GLOBAL_GRAPH = Some(graph);
    }
    println!("Connected to Neo4j database at: {}", uri);

    let mut rl = DefaultEditor::new()?;
    loop {
        let readline = rl.readline(">> ")?;
        println!("{}", readline);
        execute_query(&readline).await;
        // match readline {
        //     Ok(line) => {
        //         println!("Line: {}", line);
        //     }
        // }
    }
}

async fn execute_query(line: &String) {
    unsafe {
        if let Some(graph) = &GLOBAL_GRAPH {
            let mut result = graph.execute(query(line)).await.unwrap();
            while let Some(row) = result.next().await.unwrap() {
                println!("{:?}", row);
            }
        } else {
            println!("You need to connect to the database first.");
        }
    }
}

async fn test_query() {
    unsafe {
        if let Some(graph) = &GLOBAL_GRAPH {
            let mut result = graph
                    .execute(
                        query("MATCH (a:AS {asn: $asn})-[:NAME]-(b:Name) RETURN a.asn as asn, b.name AS name")
                            .param("asn", 2497),
                    )
                    .await
                    .unwrap();
            while let Some(row) = result.next().await.unwrap() {
                println!("{:?}", row);
            }
        } else {
            println!("You need to connect to the database first.");
        }
    }
}

// Archived
// let uri = "iyp.iijlab.net:7687";
// let user = "neo4j";
// let pass = "neo";
// let graph = Arc::new(Graph::new(uri, user, pass).await.unwrap());
// let mut result = graph
//     .execute(
//         query("MATCH (a:AS {asn: $asn})-[:NAME]-(b:Name) RETURN a.asn as asn, b.name AS name")
//             .param("asn", 2497),
//     )
//     .await
//     .unwrap();
// Without using Some()
// let row = result.next().await.unwrap().unwrap();
// println!("{:?}", row.get::<String>("name").unwrap());
// Works for one item
// let get_result = result.next().await.unwrap();
// if let Some(row) = get_result {
//     if let Some(name) = row.get::<String>("name") {
//         println!("Name: {}", name);
//     } else {
//         println!("Name property not found in the result.");
//     }
// } else {
//     println!("No result returned from the query.");
// }
// while let Some(row) = result.next().await.unwrap() {
//     if let Some(name) = DefaultEditor::row.get::<String>("name") {
//         println!("Name: {}", name);
//     } else {
//         println!("Name property not found in the result.");
//     }
// }
// while let Some(row) = result.next().await.unwrap() {
//     println!("{:?}", row);
// }
// Connect() Method Error Handling
// let result = Graph::new(uri, username, password).await;
// let graph = match result {
//     Ok(graph) => Arc::new(graph),
//     Err(err) => {
//         return Err(Error::from(err));
//     }
// };