Struct deadpool_redis::Cmd

pub struct Cmd { /* fields omitted */ }

Wrapper for redis::Cmd which makes it compatible with the query_async method which takes a ConnectionLike as argument.

This Implementation could be simplified a lot via RFC 2393.

See redis::Cmd

Implementations

impl Cmd

pub fn new() -> Self

See redis::Cmd::new

pub fn arg<T: ToRedisArgs>(&mut self, arg: T) -> &mut Cmd

See redis::Cmd::arg

pub fn cursor_arg(&mut self, cursor: u64) -> &mut Cmd

See redis::Cmd::cursor_arg

pub async fn query_async<T: FromRedisValue + Send>(
    &self,
    conn: &mut ConnectionWrapper
) -> RedisResult<T>

See redis::Cmd::query_async

pub async fn execute_async(
    &self,
    con: &mut ConnectionWrapper
) -> RedisResult<()>

See redis::Cmd::execute_async

Methods from Deref<Target = Cmd>

pub fn arg<T>(&mut self, arg: T) -> &mut Cmd where
    T: ToRedisArgs, 

Appends an argument to the command. The argument passed must be a type that implements ToRedisArgs. Most primitive types as well as vectors of primitive types implement it.

For instance all of the following are valid:

redis::cmd("SET").arg(&["my_key", "my_value"]);
redis::cmd("SET").arg("my_key").arg(42);
redis::cmd("SET").arg("my_key").arg(b"my_value");

pub fn cursor_arg(&mut self, cursor: u64) -> &mut Cmd

Works similar to arg but adds a cursor argument. This is always an integer and also flips the command implementation to support a different mode for the iterators where the iterator will ask for another batch of items when the local data is exhausted.

let mut cmd = redis::cmd("SSCAN");
let mut iter : redis::Iter<isize> =
    cmd.arg("my_set").cursor_arg(0).clone().iter(&mut con).unwrap();
for x in iter {
    // do something with the item
}

pub fn get_packed_command(&self) -> Vec<u8, Global>

Returns the packed command as a byte vector.

pub fn in_scan_mode(&self) -> bool

Returns true if the command is in scan mode.

pub fn query<T>(&self, con: &mut dyn ConnectionLike) -> Result<T, RedisError> where
    T: FromRedisValue, 

Sends the command as query to the connection and converts the result to the target redis value. This is the general way how you can retrieve data.

pub async fn query_async<C, T>(
    &'_ self,
    con: &'_ mut C
) -> Result<T, RedisError> where
    C: ConnectionLike,
    T: FromRedisValue, 

Async version of query.

pub fn execute(&self, con: &mut dyn ConnectionLike)

This is a shortcut to query() that does not return a value and will fail the task if the query fails because of an error. This is mainly useful in examples and for simple commands like setting keys.

This is equivalent to a call of query like this:

let _ : () = redis::cmd("PING").query(&mut con).unwrap();

pub fn args_iter(
    &self
) -> impl Iterator<Item = Arg<&[u8]>> + Clone + ExactSizeIterator

Returns an iterator over the arguments in this command (including the command name itself)

Trait Implementations

impl Deref for Cmd

type Target = Cmd

The resulting type after dereferencing.

fn deref(&self) -> &Cmd

Dereferences the value.

impl DerefMut for Cmd

fn deref_mut(&mut self) -> &mut Cmd

Mutably dereferences the value.

impl From<Cmd> for Cmd

fn from(cmd: Cmd) -> Self

Performs the conversion.

impl Into<Cmd> for Cmd

fn into(self) -> Cmd

Performs the conversion.