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
//! An asynchronous client for Bolt-compatible servers. //! //! # Example //! The below example demonstrates how to connect to a Neo4j server and send it Bolt messages. //! ``` //! use std::collections::HashMap; //! use std::convert::TryFrom; //! use std::iter::FromIterator; //! //! use failure::Error; //! use tokio::prelude::*; //! //! use bolt_client::*; //! use bolt_client::message::*; //! use bolt_client::value::*; //! //! #[tokio::main] //! async fn main() -> Result<(), Error> { //! // Create a new connection to the server and perform a handshake to establish a //! // protocol version. //! let mut client = Client::new_tcp("127.0.0.1:7687").await?; //! //! // You can also create a TCP connection that is secured with TLS: //! // let mut client = Client::new_secure_tcp("mydomain.com", "mydomain.com:1234").await?; //! //! // Send an INIT message with authorization details to the server to initialize //! // the session. //! let response_msg: Message = client.init( //! "my-client-name/1.0".to_string(), //! HashMap::from_iter(vec![ //! ("scheme".to_string(), "basic".to_string()), //! ("principal".to_string(), "neo4j".to_string()), //! ("credentials".to_string(), "test".to_string()), //! ])).await?; //! assert!(Success::try_from(response_msg).is_ok()); //! //! // Run a query on the server and retrieve the results //! let response_msg = client.run("RETURN 1 as num;".to_string(), None).await?; //! // Successful RUN messages will return a SUCCESS message with related metadata //! // Consuming these messages is optional and will be skipped for the rest of the example //! assert!(Success::try_from(response_msg).is_ok()); //! // Use PULL_ALL to retrieve results of the query //! let (response_msg, records): (Message, Vec<Record>) = client.pull_all().await?; //! assert!(Success::try_from(response_msg).is_ok()); //! // Note that integers are automatically packed into the smallest possible byte //! // representation. //! assert_eq!(records[0].fields(), &[Value::from(1 as i8)]); //! //! // Clear the database //! client.run("MATCH (n) DETACH DELETE n;".to_string(), None).await?; //! client.pull_all().await?; //! //! // Run a more complex query with parameters //! client.run("CREATE (:Client)-[:WRITTEN_IN]->(:Language {name: $name});".to_string(), //! Some(HashMap::from_iter( //! vec![("name".to_string(), Value::from("Rust"))] //! ))).await?; //! client.pull_all().await?; //! client.run("MATCH (rust:Language) RETURN rust;".to_string(), None).await?; //! let (response_msg, records): (Message, Vec<Record>) = client.pull_all().await?; //! assert!(Success::try_from(response_msg).is_ok()); //! //! // Access properties from returned values //! let node = Node::try_from(records[0].fields()[0].clone())?; //! assert_eq!(node.labels(), &["Language".to_string()]); //! assert_eq!(node.properties(), //! &HashMap::from_iter(vec![("name".to_string(), Value::from("Rust"))])); //! //! Ok(()) //! } //! ``` pub use bolt_proto::message; pub use bolt_proto::value; pub use bolt_proto::{Message, Value}; #[doc(inline)] pub use self::client::Client; pub mod client; mod stream;