Struct PreparedCommand

pub struct PreparedCommand<'a, E, R = ()>
where
    R: Response,
{
    pub executor: E,
    pub command: Command,
    pub custom_converter: Option<Box<dyn Fn(RespBuf, Command, &'a Client) -> Future<'a, R> + Send + Sync>>,
    pub retry_on_error: Option<bool>,
    /* private fields */
}

Wrapper around a command about to be send with a marker for the response type and a few options to decide how the response send back by Redis should be processed.

Fields

executor: E

Client, Transaction or Pipeline that will actually send the command to the Redis server.

command: Command

Command to send

custom_converter: Option<Box<dyn Fn(RespBuf, Command, &'a Client) -> Future<'a, R> + Send + Sync>>

Custom converter to transform a RESP Buffer in to R type

retry_on_error: Option<bool>

Flag to retry sending the command on network error.

Implementations

impl<'a, E, R> PreparedCommand<'a, E, R>

where R: Response,

pub fn new(executor: E, command: Command) -> Self

Create a new prepared command.

pub fn custom_converter( self, custom_converter: Box<dyn Fn(RespBuf, Command, &'a Client) -> Future<'a, R> + Send + Sync>, ) -> Self

Set the functor [self.custom_converter]

pub fn retry_on_error(self, retry_on_error: bool) -> Self

Set a flag to override default retry_on_error behavior.

See Config::retry_on_error

pub fn command(&self) -> &Command

Get a reference to the command to send

Trait Implementations

impl<'a, R: Response> BatchPreparedCommand for PreparedCommand<'a, &'a mut Pipeline<'_>, R>

fn queue(self)

Queue a command.

fn forget(self)

Queue a command and forget its response.

impl<'a, R: Response> BatchPreparedCommand for PreparedCommand<'a, &'a mut Transaction, R>

fn queue(self)

Queue a command into the transaction.

fn forget(self)

Queue a command into the transaction and forget its response.

impl<'a, R: Response> ClientPreparedCommand<'a, R> for PreparedCommand<'a, &'a Client, R>

fn forget(self) -> Result<()>

Send command and forget its response

Errors

Any Redis driver Error that occur during the send operation

impl<'a, R> IntoFuture for PreparedCommand<'a, &'a Client, R>

where R: DeserializeOwned + Send + 'a,

type Output = Result<R, Error>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = Result<R, Error>> + Send + 'a>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl<'a, R> IntoFuture for PreparedCommand<'a, &'a mut Connection, R>

where R: DeserializeOwned + Send + 'a,

type Output = Result<R, Error>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = Result<R, Error>> + Send + 'a>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl<'a, R> IntoFuture for PreparedCommand<'a, &'a mut StandaloneConnection, R>

where R: DeserializeOwned + Send + 'a,

type Output = Result<R, Error>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = Result<R, Error>> + Send + 'a>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.