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

//! redis-raw-rs is a minimal Redis client library implementation.
//! It exposes a general purpose interface to Redis.
//!
//! The crate is called `redis_raw` and you can depend on it via cargo:
//!
//! ```ini
//! [dependencies]
//! redis_raw = "*"
//! ```
//!
//! If you want to use the git version:
//!
//! ```ini
//! [dependencies]
//! redis_raw = { version = "*", git = "git@github.com:aminroosta/redis-raw-rs.git" }
//! ```
//!
//! # Basic Operation
//!
//! `redis_raw` exposes two API levels: a low- and a lower-level part!  
//! The `low-level` part does not expose all the functionality of redis and
//! might take some liberties in how it speaks the protocol.  The `lower-level`
//! part of the API allows you to express any request on the redis level.
//! You can fluently switch between both API levels at any point.
//!
//! ## Connection Handling
//!
//! For connecting to redis you can use `tokio::net::TcpStream` which can be
//! converted to (or from) `RedisConnection`.
//!
//! ```rust,no_run
//! use redis_raw::RedisConnection;
//! use tokio::net::TcpStream;
//!
//! async fn do_something()
//!  -> std::result::Result<(), Box<dyn std::error::Error>> {
//!
//!    let stream = TcpStream::connect("127.0.0.1:6379").await?;
//!    let mut con: RedisConnection = stream.into();
//!
//!     /* do something here */
//!
//!     Ok(())
//! }
//! # fn main() {}
//! ```
//!
//! ## Executing Lower-Level Commands
//!
//! To execute lower-level commands you can use the `write()` and `read()` functions
//! which allow you to make redis requests and parse redis (RESP) responses.
//! These functions correspond to the underlying socket's read and write operations.
//!
//! The `read()` function parses the RESP response as `redis_raw::Value`.  
//! `Value` Represents a redis [RESP protcol response](https://redis.io/topics/protocol#resp-protocol-description).  
//!
//! ```rust,no_run
//! use redis_raw::{RedisConnection, RedisResult, Value }
//!
//! fn do_something(con: &mut RedisConnection) -> RedisResult<Value> {
//!    con.write("set key vvv\r\n").await?
//!    con.read().await
//! }
//! ```
//!
//! ## Executing Low-Level Commands
//!
//! The low-level interface is similar. The `command()` function does a
//! `write()` and a `read()` and converts the `Value` into requested type.
//!
//! ```rust,no_run
//! use redis_raw::{RedisConnection, RedisResult, Value }
//!
//! fn do_something(con: &mut RedisConnection) -> RedisResult<String> {
//!    con.command::<()>("set key value\r\n".to_owned()).await?;
//!    con.command::<i64>("append key !!!\r\n".to_owned()).await?;
//!    con.command::<String>("get key\r\n".to_owned()).await
//! }
//! ```
//!
//! Here is another example, to find out the correct result type see [redis docs](https://redis.io/commands).
//!
//! ```rust,no_run
//! use redis_raw::{RedisConnection, RedisResult, Value }
//!
//! fn do_something(con: &mut RedisConnection) -> RedisResult<Vec<String>> {
//!    for i in 1..10 {
//!        con.command::<i64>(format!("zadd myset {} {}\r\n", i, i*i)).await?;
//!    }
//!    con.command::<Vec<String>>("zrange myset 0 -1\r\n".to_owned()).await
//! }
//! ```
//!
//! The following return types are supported:
//! `()`, `i64`, `String`, `Vec<i64>`, and `Vec<String>`
//!

pub use crate::connection::RedisConnection;
pub use crate::serialize::decode;
pub use crate::types::{RedisError, RedisResult, Value};

mod connection;
mod serialize;
mod types;