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

//! Rust crate for accessing the cypher endpoint of a neo4j server
//!
//! This crate allows you to send cypher queries to the REST endpoint of a neo4j database. You can
//! execute queries inside a transaction or simply send queries that commit immediately.
//!
//! # Examples
//!
//! ## Connecting to a Neo4j database
//!
//! ```
//! use rusted_cypher::GraphClient;
//! let graph = GraphClient::connect(
//!     "http://neo4j:neo4j@localhost:7474/db/data");
//! # graph.unwrap();
//! ```
//!
//! ## Performing Queries
//!
//! ```
//! # use rusted_cypher::{GraphClient, Statement, GraphError};
//! # fn main() { doctest().unwrap(); }
//! # fn doctest() -> Result<(), GraphError> {
//! # let graph = GraphClient::connect("http://neo4j:neo4j@localhost:7474/db/data")?;
//! let mut query = graph.query();
//!
//! // Statement implements From<&str>
//! query.add_statement(
//!     "CREATE (n:LANG { name: 'Rust', level: 'low', safe: true })");
//!
//! let statement = Statement::new(
//!     "CREATE (n:LANG { name: 'C++', level: 'low', safe: {safeness} })")
//!     .with_param("safeness", false)?;
//!
//! query.add_statement(statement);
//!
//! query.send()?;
//!
//! graph.exec(
//!     "CREATE (n:LANG { name: 'Python', level: 'high', safe: true })")?;
//!
//! let result = graph.exec(
//!     "MATCH (n:LANG) RETURN n.name, n.level, n.safe")?;
//!
//! assert_eq!(result.data.len(), 3);
//!
//! for row in result.rows() {
//!     let name: String = row.get("n.name")?;
//!     let level: String = row.get("n.level")?;
//!     let safeness: bool = row.get("n.safe")?;
//!     println!("name: {}, level: {}, safe: {}", name, level, safeness);
//! }
//!
//! graph.exec("MATCH (n:LANG) DELETE n")?;
//! # Ok(())
//! # }
//! ```
//!
//! ## With Transactions
//!
//! ```
//! # use std::collections::BTreeMap;
//! # use rusted_cypher::{GraphClient, Statement, GraphError};
//! # fn main() { doctest().unwrap(); }
//! # fn doctest() -> Result<(), GraphError> {
//! # let graph = GraphClient::connect("http://neo4j:neo4j@localhost:7474/db/data")?;
//! let transaction = graph
//!     .transaction()
//!     .with_statement(
//!         "CREATE (n:IN_TRANSACTION { name: 'Rust', level: 'low', safe: true })");
//!
//! let (mut transaction, results) = transaction.begin().unwrap();
//!
//! // Use `exec` to execute a single statement
//! transaction.exec("CREATE (n:IN_TRANSACTION { name: 'Python', level: 'high', safe: true })")?;
//!
//! // use `add_statement` (or `with_statement`) and `send` to executes multiple statements
//! let stmt = Statement::new(
//!     "MATCH (n:IN_TRANSACTION) WHERE (n.safe = {safeness}) RETURN n")
//!     .with_param("safeness", true)?;
//!
//! transaction.add_statement(stmt);
//! let results = transaction.send()?;
//!
//! assert_eq!(results[0].data.len(), 2);
//!
//! transaction.rollback()?;
//! # Ok(())
//! }
//! ```
//!
//! ## Statements with Macro
//!
//! There is a macro to help building statements
//!
//! ```
//! # #[macro_use] extern crate rusted_cypher;
//! # use rusted_cypher::{GraphClient, Statement, GraphError};
//! # fn main() { doctest().unwrap(); }
//! # fn doctest() -> Result<(), GraphError> {
//! # let graph = GraphClient::connect("http://neo4j:neo4j@localhost:7474/db/data")?;
//! let statement = cypher_stmt!(
//!     "CREATE (n:WITH_MACRO { name: {name}, level: {level}, safe: {safe} })", {
//!         "name" => "Rust",
//!         "level" => "low",
//!         "safe" => true
//!     }
//! )?;
//! graph.exec(statement)?;
//!
//! let statement = cypher_stmt!(
//!     "MATCH (n:WITH_MACRO) WHERE n.name = {name} RETURN n", {
//!         "name" => "Rust"
//!     }
//! )?;
//!
//! let results = graph.exec(statement)?;
//! assert_eq!(results.data.len(), 1);
//!
//! let statement = cypher_stmt!("MATCH (n:WITH_MACRO) DELETE n")?;
//! graph.exec(statement)?;
//! # Ok(())
//! # }
//! ```

extern crate hyper;
pub extern crate serde;
pub extern crate serde_json;

#[macro_use]
extern crate serde_derive;

extern crate semver;
extern crate time;

#[macro_use]
extern crate quick_error;

#[macro_use]
extern crate log;

pub mod cypher;
pub mod graph;
pub mod error;

pub use graph::GraphClient;
pub use cypher::Statement;
pub use error::GraphError;