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
//! redis_graph proivdes a small trait with an extension function for the //! [redis](https://docs.rs/redis/) crate to allow working with redis graph //! data types that can be installed as a [redis module](https://oss.redislabs.com/redisgraph). //! Redis graph operation are only using a single top level Redis command, so //! this crate only adds a single function to the redis commands. //! The Graph command is available in a synchronous and asynchronous version. //! //! The crate is called `redis-graph` and you can depend on it via cargo. You will //! also need redis in your dependencies. //! //! ```ini //! [dependencies] //! redis = "0.19.0" //! redis-graph = "*" //! ``` //! //! Or via git: //! //! ```ini //! [dependencies.redis-graph] //! git = "https://github.com/tompro/redis_graph.git" //! branch = "main" //! ``` //! //! With async feature inherited from the [redis](https://docs.rs/redis) //! crate (either: 'async-std-comp' or 'tokio-comp): //! //! ```ini //! [dependencies] //! redis = "0.19.0" //! redis-graph = { version = "0.2.0", features = ['tokio-comp'] } //! ``` //! //! # Synchronous usage //! //! To enable the redis graph command you simply load the trait //! redis_graph::GraphCommands into scope. The redis graph //! command will then be available on your redis connection. //! To also have access to the value extractor traits simply import //! the whole crate redis_graph::*. //! //! //! ```rust,no_run //! # fn run() -> redis::RedisResult<()> { //! use redis::Commands; //! use redis_graph::*; //! //! let client = redis::Client::open("redis://127.0.0.1/")?; //! let mut con = client.get_connection()?; //! //! let _:GraphResultSet = con.graph_query( //! "my_graph", //! "CREATE (:Rider {name:'Valentino Rossi'})-[:rides]->(:Team {name:'Yamaha'})" //! )?; //! # Ok(()) } //! ``` //! //! //! # Asynchronous usage //! //! To enable the redis graph async command you simply load the //! redis_graph::AsyncGraphCommands into the scope. To also have access //! to the value extractor traits simply import the whole crate redis_graph::*. //! //! ```rust,no_run //! # #[cfg(any(feature = "tokio-comp", feature = "async-std-comp"))] //! # async fn run() -> redis::RedisResult<()> { //! use redis::AsyncCommands; //! use redis_graph::*; //! //! let client = redis::Client::open("redis://127.0.0.1/")?; //! let mut con = client.get_async_connection().await?; //! //! let _:GraphResultSet = con.graph_query( //! "my_graph", //! "CREATE (:Rider {name:'Valentino Rossi'})-[:rides]->(:Team {name:'Yamaha'})" //! ).await?; //! # Ok(()) } //! ``` //! //! # Commands //! //! The following examples work with the synchronous and asynchronous API. For //! simplicity all examples will use the synchronous API. To use them async simply //! run them within an async function and append the .await after the command call. //! //! ## GRAPH.QUERY //! The query command is the only command required for all graph operations. It will //! produce a GraphResultSet that contains the results of the operation. As queries //! are very flexible a lot of different data stuctures can be contained in a //! GraphResultSet. //! //! ```rust,no_run //! # fn run() -> redis::RedisResult<()> { //! use redis::Commands; //! use redis_graph::*; //! //! let client = redis::Client::open("redis://127.0.0.1/")?; //! let mut con = client.get_connection()?; //! //! /// A create query returns metadata as a list of strings //! let r:GraphResultSet = con.graph_query( //! "my_graph", //! "CREATE (:Rider {name:'Valentino Rossi'})-[:rides]->(:Team {name:'Yamaha'})" //! )?; //! assert!(!r.metadata.is_empty()); //! //! //! /// This query will return nodes and scalars in the result //! let riders = con.graph_query( //! "my_graph", //! "MATCH (rider:Rider)-[:rides]->(team:Team) //! WHERE team.name = 'Yamaha' //! RETURN rider, team.name" //! )?; //! //! //! /// Data contains a vec of GraphResult with one entry per query match. //! assert!(riders.data.len() > 0); //! //! //! /// A GraphResult is indexed with the identifiers used in the RETURN //! /// clause of the query. A result has some convenience functions to //! /// extract GraphValues (Scalar|Node|Relation) into rust types. //! let entry = riders.data.get(0).unwrap(); //! let rider:Option<&NodeValue> = entry.get_node("rider"); //! let team_name:Option<String> = entry.get_scalar("team.name"); //! //! //! /// Node and Relation values can contain properties for which there are //! /// value extractors as well. //! let rider_name:Option<String> = rider.unwrap().get_property_option("name"); //! //! # Ok(()) } #[cfg(any(feature = "tokio-comp", feature = "async-std-comp"))] pub use crate::async_commands::AsyncGraphCommands; pub use crate::commands::GraphCommands; pub use crate::types::*; #[cfg(any(feature = "tokio-comp", feature = "async-std-comp"))] mod async_commands; mod commands; mod types;