Struct redis_driver::Transaction

pub struct Transaction { /* private fields */ }

Implementations

impl Transaction

pub fn new(database: Database) -> Self

pub fn send<'a>(
    &'a self,
    command: Command
) -> impl Future<Output = Result<Value>> + 'a

pub async fn execute(&self) -> Result<()>

Trait Implementations

impl CommandSend for Transaction

fn send(
    &self,
    command: Command
) -> Pin<Box<dyn Future<Output = Result<Value>> + Send + '_>>

Send an arbitrary command to the server.

fn send_into<T: FromValue>(
    &self,
    command: Command
) -> Pin<Box<dyn Future<Output = Result<T>> + Send + '_>>

impl GenericCommands for Transaction

fn copy<S, D>(&self, source: S, destination: D) -> Copy<'_, Self>where
    S: Into<BulkString> + Send,
    D: Into<BulkString> + Send,

This command copies the value stored at the source key to the destination key.

fn del<K>(&self, keys: K) -> Pin<Box<dyn Future<Output = Result<usize>> + '_>>where
    K: IntoArgs + Send,

Removes the specified keys. A key is ignored if it does not exist.

fn exists<K>(&self, keys: K) -> Pin<Box<dyn Future<Output = Result<usize>> + '_>>where
    K: IntoArgs + Send,

Returns if keys exist.

fn expire<K>(&self, key: K, seconds: u64) -> Expire<'_, Self>where
    K: Into<BulkString> + Send,

Set a timeout on key in seconds

fn expireat<K>(&self, key: K, unix_time_seconds: u64) -> Expire<'_, Self>where
    K: Into<BulkString> + Send,

EXPIREAT has the same effect and semantic as EXPIRE, but instead of specifying the number of seconds representing the TTL (time to live), it takes an absolute Unix timestamp (seconds since January 1, 1970)

fn expiretime<K>(
    &self,
    key: K
) -> Pin<Box<dyn Future<Output = Result<i64>> + '_>>where
    K: Into<BulkString> + Send,

Returns the absolute Unix timestamp (since January 1, 1970) in seconds at which the given key will expire.

fn move_<K>(
    &self,
    key: K,
    db: usize
) -> Pin<Box<dyn Future<Output = Result<bool>> + '_>>where
    K: Into<BulkString> + Send,

Move key from the currently selected database to the specified destination database.

fn persist<K>(&self, key: K) -> Pin<Box<dyn Future<Output = Result<bool>> + '_>>where
    K: Into<BulkString> + Send,

Remove the existing timeout on key, turning the key from volatile (a key with an expire set) to persistent (a key that will never expire as no timeout is associated).

fn pexpire<K>(&self, key: K, milliseconds: u64) -> Expire<'_, Self>where
    K: Into<BulkString> + Send,

This command works exactly like EXPIRE but the time to live of the key is specified in milliseconds instead of seconds.

fn pexpireat<K>(&self, key: K, unix_time_milliseconds: u64) -> Expire<'_, Self>where
    K: Into<BulkString> + Send,

PEXPIREAT has the same effect and semantic as EXPIREAT, but the Unix time at which the key will expire is specified in milliseconds instead of seconds.

fn pexpiretime<K>(
    &self,
    key: K
) -> Pin<Box<dyn Future<Output = Result<i64>> + '_>>where
    K: Into<BulkString> + Send,

PEXPIRETIME has the same semantic as EXPIRETIME, but returns the absolute Unix expiration timestamp in milliseconds instead of seconds.

fn pttl<K>(&self, key: K) -> Pin<Box<dyn Future<Output = Result<i64>> + '_>>where
    K: Into<BulkString> + Send,

Returns the remaining time to live of a key that has a timeout.

fn ttl<K>(&self, key: K) -> Pin<Box<dyn Future<Output = Result<i64>> + '_>>where
    K: Into<BulkString> + Send,

Returns the remaining time to live of a key that has a timeout.

fn type_<K>(&self, key: K) -> Pin<Box<dyn Future<Output = Result<String>> + '_>>where
    K: Into<BulkString> + Send,

Returns the string representation of the type of the value stored at key.

impl HashCommands for Transaction

fn hdel<K, F>(
    &self,
    key: K,
    fields: F
) -> Pin<Box<dyn Future<Output = Result<usize>> + '_>>where
    K: Into<BulkString> + Send,
    F: IntoArgs + Send,

Removes the specified fields from the hash stored at key.

fn hexists<K, F>(
    &self,
    key: K,
    field: F
) -> Pin<Box<dyn Future<Output = Result<bool>> + '_>>where
    K: Into<BulkString> + Send,
    F: Into<BulkString> + Send,

Returns if field is an existing field in the hash stored at key.

fn hget<'a, K, F, V>(
    &'a self,
    key: K,
    field: F
) -> Pin<Box<dyn Future<Output = Result<V>> + 'a>>where
    K: Into<BulkString> + Send,
    F: Into<BulkString> + Send,
    V: FromValue + Send + 'a,

Returns the value associated with field in the hash stored at key.

fn hgetall<'a, K, F, V>(
    &'a self,
    key: K
) -> Pin<Box<dyn Future<Output = Result<Vec<(F, V)>>> + 'a>>where
    K: Into<BulkString> + Send,
    F: FromValue + Send + 'a,
    V: FromValue + Send + 'a,

Returns all fields and values of the hash stored at key.

fn hincrby<K, F>(
    &self,
    key: K,
    field: F,
    increment: i64
) -> Pin<Box<dyn Future<Output = Result<i64>> + '_>>where
    K: Into<BulkString> + Send,
    F: Into<BulkString> + Send,

Increments the number stored at field in the hash stored at key by increment.

fn hincrbyfloat<K, F>(
    &self,
    key: K,
    field: F,
    increment: f64
) -> Pin<Box<dyn Future<Output = Result<f64>> + '_>>where
    K: Into<BulkString> + Send,
    F: Into<BulkString> + Send,

Increment the specified field of a hash stored at key, and representing a floating point number, by the specified increment.

fn hkeys<'a, K, F>(
    &'a self,
    key: K
) -> Pin<Box<dyn Future<Output = Result<Vec<F>>> + 'a>>where
    K: Into<BulkString> + Send,
    F: FromValue + Send + 'a,

Returns all field names in the hash stored at key.

fn hlen<K>(&self, key: K) -> Pin<Box<dyn Future<Output = Result<usize>> + '_>>where
    K: Into<BulkString> + Send,

Returns the number of fields contained in the hash stored at key.

fn hmget<'a, K, F, V>(
    &'a self,
    key: K,
    fields: F
) -> Pin<Box<dyn Future<Output = Result<Vec<V>>> + 'a>>where
    K: Into<BulkString> + Send,
    F: IntoArgs + Send,
    V: FromValue + Send + 'a,

Returns the values associated with the specified fields in the hash stored at key.

fn hrandfield<K>(&self, key: K) -> HRandField<'_, Self>where
    K: Into<BulkString> + Send,

When called with just the key argument, return a random field from the hash value stored at key.

fn hscan<K>(&self, key: K, cursor: usize) -> HScan<'_, Self>where
    K: Into<BulkString> + Send,

Iterates fields of Hash types and their associated values.

fn hset<K, F, V>(
    &self,
    key: K,
    items: &[(F, V)]
) -> Pin<Box<dyn Future<Output = Result<usize>> + '_>>where
    K: Into<BulkString> + Send + Sync,
    F: Into<BulkString> + Send + Sync + Clone,
    V: Into<BulkString> + Send + Sync + Clone,

Sets field in the hash stored at key to value.

fn hsetnx<K, F, V>(
    &self,
    key: K,
    field: F,
    value: V
) -> Pin<Box<dyn Future<Output = Result<bool>> + '_>>where
    K: Into<BulkString> + Send + Sync + Copy,
    F: Into<BulkString> + Send + Sync + Copy,
    V: Into<BulkString> + Send + Sync + Copy,

Sets field in the hash stored at key to value, only if field does not yet exist.

fn hstrlen<K, F>(
    &self,
    key: K,
    field: F
) -> Pin<Box<dyn Future<Output = Result<usize>> + '_>>where
    K: Into<BulkString> + Send + Sync + Copy,
    F: Into<BulkString> + Send + Sync + Copy,

Returns the string length of the value associated with field in the hash stored at key.

fn hvals<'a, K, V>(
    &'a self,
    key: K
) -> Pin<Box<dyn Future<Output = Result<Vec<V>>> + 'a>>where
    K: Into<BulkString> + Send + Sync + Copy,
    V: FromValue + Send + 'a,

list of values in the hash, or an empty list when key does not exist.

impl ListCommands for Transaction

fn lpush<K, E>(
    &self,
    key: K,
    elements: E
) -> Pin<Box<dyn Future<Output = Result<i64>> + '_>>where
    K: Into<BulkString> + Send,
    E: IntoArgs + Send,

Insert all the specified values at the head of the list stored at key

fn lpop<K, E>(
    &self,
    key: K,
    count: usize
) -> Pin<Box<dyn Future<Output = Result<Vec<E>>> + '_>>where
    K: Into<BulkString> + Send,
    E: FromValue,

Removes and returns the first elements of the list stored at key.

fn rpush<K, E>(
    &self,
    key: K,
    elements: E
) -> Pin<Box<dyn Future<Output = Result<i64>> + '_>>where
    K: Into<BulkString> + Send,
    E: IntoArgs + Send,

Insert all the specified values at the tail of the list stored at key

fn rpop<K, E>(
    &self,
    key: K,
    count: usize
) -> Pin<Box<dyn Future<Output = Result<Vec<E>>> + '_>>where
    K: Into<BulkString> + Send,
    E: FromValue,

Removes and returns the first elements of the list stored at key.

impl ServerCommands for Transaction

fn flushdb(
    &self,
    flushing_mode: FlushingMode
) -> Pin<Box<dyn Future<Output = Result<()>> + '_>>

Delete all the keys of the currently selected DB.

fn flushall(
    &self,
    flushing_mode: FlushingMode
) -> Pin<Box<dyn Future<Output = Result<()>> + '_>>

Delete all the keys of all the existing databases, not just the currently selected one.

impl SetCommands for Transaction

fn sadd<K, M>(
    &self,
    key: K,
    members: M
) -> Pin<Box<dyn Future<Output = Result<usize>> + '_>>where
    K: Into<BulkString>,
    M: IntoArgs,

Add the specified members to the set stored at key.

fn scard<K>(&self, key: K) -> Pin<Box<dyn Future<Output = Result<usize>> + '_>>where
    K: Into<BulkString>,

Returns the set cardinality (number of elements) of the set stored at key.

fn sdiff<K, M>(
    &self,
    keys: K
) -> Pin<Box<dyn Future<Output = Result<HashSet<M>>> + '_>>where
    K: IntoArgs,
    M: FromValue + Eq + Hash,

Returns the members of the set resulting from the difference between the first set and all the successive sets.

fn sdiffstore<D, K>(
    &self,
    destination: D,
    keys: K
) -> Pin<Box<dyn Future<Output = Result<usize>> + '_>>where
    D: Into<BulkString>,
    K: IntoArgs,

This command is equal to sdiff, but instead of returning the resulting set, it is stored in destination.

fn sinter<K, M>(
    &self,
    keys: K
) -> Pin<Box<dyn Future<Output = Result<HashSet<M>>> + '_>>where
    K: IntoArgs,
    M: FromValue + Eq + Hash,

Returns the members of the set resulting from the intersection of all the given sets.

fn sintercard<K>(
    &self,
    keys: K,
    limit: usize
) -> Pin<Box<dyn Future<Output = Result<usize>> + '_>>where
    K: IntoArgs,

This command is similar to sinter, but instead of returning the result set, it returns just the cardinality of the result.

fn sinterstore<D, K>(
    &self,
    destination: D,
    keys: K
) -> Pin<Box<dyn Future<Output = Result<usize>> + '_>>where
    D: Into<BulkString>,
    K: IntoArgs,

This command is equal to sinter, but instead of returning the resulting set, it is stored in destination.

fn sismember<K, M>(
    &self,
    key: K,
    member: M
) -> Pin<Box<dyn Future<Output = Result<bool>> + '_>>where
    K: Into<BulkString>,
    M: Into<BulkString>,

Returns if member is a member of the set stored at key.

fn smembers<K, M>(
    &self,
    key: K
) -> Pin<Box<dyn Future<Output = Result<HashSet<M>>> + '_>>where
    K: Into<BulkString>,
    M: FromValue + Eq + Hash,

Returns all the members of the set value stored at key.

fn smismember<K, M>(
    &self,
    key: K,
    members: M
) -> Pin<Box<dyn Future<Output = Result<Vec<bool>>> + '_>>where
    K: Into<BulkString>,
    M: IntoArgs,

Returns whether each member is a member of the set stored at key.

fn smove<S, D, M>(
    &self,
    source: S,
    destination: D,
    member: M
) -> Pin<Box<dyn Future<Output = Result<bool>> + '_>>where
    S: Into<BulkString>,
    D: Into<BulkString>,
    M: Into<BulkString>,

Move member from the set at source to the set at destination.

fn spop<K, M>(
    &self,
    key: K,
    count: usize
) -> Pin<Box<dyn Future<Output = Result<HashSet<M>>> + '_>>where
    K: Into<BulkString>,
    M: FromValue + Eq + Hash,

Removes and returns one or more random members from the set value store at key.

fn srandmember<K, M>(
    &self,
    key: K,
    count: usize
) -> Pin<Box<dyn Future<Output = Result<HashSet<M>>> + '_>>where
    K: Into<BulkString>,
    M: FromValue + Eq + Hash,

Removes and returns one or more random members from the set value store at key.

fn srem<K, M>(
    &self,
    key: K,
    members: M
) -> Pin<Box<dyn Future<Output = Result<usize>> + '_>>where
    K: Into<BulkString>,
    M: IntoArgs,

Remove the specified members from the set stored at key.

fn sscan<K>(&self, key: K, cursor: usize) -> SScan<'_, Self>where
    K: Into<BulkString> + Send,

Iterates elements of Sets types.

fn sunion<K, M>(
    &self,
    keys: K
) -> Pin<Box<dyn Future<Output = Result<HashSet<M>>> + '_>>where
    K: IntoArgs,
    M: FromValue + Eq + Hash,

Returns the members of the set resulting from the union of all the given sets.

fn sunionstore<D, K>(
    &self,
    destination: D,
    keys: K
) -> Pin<Box<dyn Future<Output = Result<usize>> + '_>>where
    D: Into<BulkString>,
    K: IntoArgs,

This command is equal to sunion, but instead of returning the resulting set, it is stored in destination.

impl StringCommands for Transaction

fn append<K, V>(
    &self,
    key: K,
    value: V
) -> Pin<Box<dyn Future<Output = Result<usize>> + '_>>where
    K: Into<BulkString> + Send,
    V: Into<BulkString> + Send,

If key already exists and is a string, this command appends the value at the end of the string. If key does not exist it is created and set as an empty string, so APPEND will be similar to SET in this special case.

fn decr<K>(&self, key: K) -> Pin<Box<dyn Future<Output = Result<i64>> + '_>>where
    K: Into<BulkString> + Send,

Decrements the number stored at key by one.

fn decrby<K>(
    &self,
    key: K,
    decrement: i64
) -> Pin<Box<dyn Future<Output = Result<i64>> + '_>>where
    K: Into<BulkString> + Send,

Decrements the number stored at key by one.

fn get<'a, K, V>(
    &'a self,
    key: K
) -> Pin<Box<dyn Future<Output = Result<V>> + 'a>>where
    K: Into<BulkString> + Send,
    V: FromValue + Send + 'a,
    Self: Sized,

Get the value of key.

fn getdel<K, V>(&self, key: K) -> Pin<Box<dyn Future<Output = Result<V>> + '_>>where
    K: Into<BulkString> + Send,
    V: FromValue,

Get the value of key and delete the key.

fn getex<K>(&self, key: K) -> GetEx<'_, Self>where
    K: Into<BulkString> + Send,

Get the value of key and optionally set its expiration. GETEX is similar to GET, but is a write command with additional options.

fn getrange<K, V>(
    &self,
    key: K,
    start: usize,
    end: isize
) -> Pin<Box<dyn Future<Output = Result<V>> + '_>>where
    K: Into<BulkString> + Send,
    V: FromValue,

Returns the substring of the string value stored at key, determined by the offsets start and end (both are inclusive).

fn getset<K, V, R>(
    &self,
    key: K,
    value: V
) -> Pin<Box<dyn Future<Output = Result<R>> + '_>>where
    K: Into<BulkString> + Send,
    V: Into<BulkString> + Send,
    R: FromValue,

Atomically sets key to value and returns the old value stored at key. Returns an error when key exists but does not hold a string value. Any previous time to live associated with the key is discarded on successful SET operation.

fn incr<K>(&self, key: K) -> Pin<Box<dyn Future<Output = Result<i64>> + '_>>where
    K: Into<BulkString> + Send,

Increments the number stored at key by one.

fn incrby<K>(
    &self,
    key: K,
    increment: i64
) -> Pin<Box<dyn Future<Output = Result<i64>> + '_>>where
    K: Into<BulkString> + Send,

Increments the number stored at key by increment.

fn incrbyfloat<K>(
    &self,
    key: K,
    increment: f64
) -> Pin<Box<dyn Future<Output = Result<f64>> + '_>>where
    K: Into<BulkString> + Send,

Increment the string representing a floating point number stored at key by the specified increment. By using a negative increment value, the result is that the value stored at the key is decremented (by the obvious properties of addition). If the key does not exist, it is set to 0 before performing the operation. An error is returned if one of the following conditions occur:

fn lcs<K>(&self, key1: K, key2: K) -> Lcs<'_, Self>where
    K: Into<BulkString> + Send,

The LCS command implements the longest common subsequence algorithm

fn mget<'a, K, V>(
    &'a self,
    keys: K
) -> Pin<Box<dyn Future<Output = Result<Vec<Option<V>>>> + '_>>where
    K: IntoArgs + Send + Sync,
    V: FromValue,

Returns the values of all specified keys.

fn mset<'a, K, V>(
    &'a self,
    items: &'a [(K, V)]
) -> Pin<Box<dyn Future<Output = Result<()>> + '_>>where
    K: Into<BulkString> + Send + Sync + Copy,
    V: Into<BulkString> + Send + Sync + Copy,

Sets the given keys to their respective values.

fn msetnx<'a, K, V>(
    &'a self,
    items: &'a [(K, V)]
) -> Pin<Box<dyn Future<Output = Result<bool>> + '_>>where
    K: Into<BulkString> + Send + Sync + Copy,
    V: Into<BulkString> + Send + Sync + Copy,

Sets the given keys to their respective values. MSETNX will not perform any operation at all even if just a single key already exists.

fn psetex<K, V>(
    &self,
    key: K,
    milliseconds: u64,
    value: V
) -> Pin<Box<dyn Future<Output = Result<()>> + '_>>where
    K: Into<BulkString> + Send,
    V: Into<BulkString> + Send,

Works exactly like setex with the sole difference that the expire time is specified in milliseconds instead of seconds.

fn set<K, V>(
    &self,
    key: K,
    value: V
) -> Pin<Box<dyn Future<Output = Result<()>> + '_>>where
    K: Into<BulkString> + Send,
    V: Into<BulkString> + Send,
    Self: Sized,

Set key to hold the string value.

fn set_with_options<K, V>(&self, key: K, value: V) -> SetWithOptions<'_, Self>where
    K: Into<BulkString> + Send,
    V: Into<BulkString> + Send,

Set key to hold the string value.

fn setex<K, V>(
    &self,
    key: K,
    seconds: u64,
    value: V
) -> Pin<Box<dyn Future<Output = Result<()>> + '_>>where
    K: Into<BulkString> + Send,
    V: Into<BulkString> + Send,

Set key to hold the string value and set key to timeout after a given number of seconds.

fn setnx<K, V>(
    &self,
    key: K,
    value: V
) -> Pin<Box<dyn Future<Output = Result<bool>> + '_>>where
    K: Into<BulkString> + Send,
    V: Into<BulkString> + Send,

Set key to hold string value if key does not exist.

fn setrange<K, V>(
    &self,
    key: K,
    offset: usize,
    value: V
) -> Pin<Box<dyn Future<Output = Result<usize>> + '_>>where
    K: Into<BulkString> + Send,
    V: Into<BulkString> + Send,

Overwrites part of the string stored at key, starting at the specified offset, for the entire length of value.

fn strlen<K>(&self, key: K) -> Pin<Box<dyn Future<Output = Result<usize>> + '_>>where
    K: Into<BulkString> + Send,

Returns the length of the string value stored at key.