Trait redis_driver::StringCommands

source · [−]
pub trait StringCommands {

Show 22 methods    fn append<'life0, 'async_trait, K, V>(
        &'life0 self,
        key: K,
        value: V
    ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>
    where
        K: Into<BulkString> + Send,
        V: Into<BulkString> + Send,
        K: 'async_trait,
        V: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;
    fn decr<'life0, 'async_trait, K>(
        &'life0 self,
        key: K
    ) -> Pin<Box<dyn Future<Output = Result<i64>> + Send + 'async_trait>>
    where
        K: Into<BulkString> + Send,
        K: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;
    fn decrby<'life0, 'async_trait, K>(
        &'life0 self,
        key: K,
        decrement: i64
    ) -> Pin<Box<dyn Future<Output = Result<i64>> + Send + 'async_trait>>
    where
        K: Into<BulkString> + Send,
        K: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;
    fn get<'life0, 'async_trait, K, V>(
        &'life0 self,
        key: K
    ) -> Pin<Box<dyn Future<Output = Result<V>> + Send + 'async_trait>>
    where
        K: Into<BulkString> + Send,
        V: FromValue,
        K: 'async_trait,
        V: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;
    fn getdel<'life0, 'async_trait, K, V>(
        &'life0 self,
        key: K
    ) -> Pin<Box<dyn Future<Output = Result<V>> + Send + 'async_trait>>
    where
        K: Into<BulkString> + Send,
        V: FromValue,
        K: 'async_trait,
        V: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;
    fn getex<K>(&self, key: K) -> GetEx<'_>
    where
        K: Into<BulkString> + Send;
    fn getrange<'life0, 'async_trait, K, V>(
        &'life0 self,
        key: K,
        start: usize,
        end: isize
    ) -> Pin<Box<dyn Future<Output = Result<V>> + Send + 'async_trait>>
    where
        K: Into<BulkString> + Send,
        V: FromValue,
        K: 'async_trait,
        V: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;
    fn getset<'life0, 'async_trait, K, V, R>(
        &'life0 self,
        key: K,
        value: V
    ) -> Pin<Box<dyn Future<Output = Result<R>> + Send + 'async_trait>>
    where
        K: Into<BulkString> + Send,
        V: Into<BulkString> + Send,
        R: FromValue,
        K: 'async_trait,
        V: 'async_trait,
        R: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;
    fn incr<'life0, 'async_trait, K>(
        &'life0 self,
        key: K
    ) -> Pin<Box<dyn Future<Output = Result<i64>> + Send + 'async_trait>>
    where
        K: Into<BulkString> + Send,
        K: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;
    fn incrby<'life0, 'async_trait, K>(
        &'life0 self,
        key: K,
        increment: i64
    ) -> Pin<Box<dyn Future<Output = Result<i64>> + Send + 'async_trait>>
    where
        K: Into<BulkString> + Send,
        K: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;
    fn incrbyfloat<'life0, 'async_trait, K>(
        &'life0 self,
        key: K,
        increment: f64
    ) -> Pin<Box<dyn Future<Output = Result<f64>> + Send + 'async_trait>>
    where
        K: Into<BulkString> + Send,
        K: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;
    fn lcs<K>(&self, key1: K, key2: K) -> Lcs<'_>
    where
        K: Into<BulkString> + Send;
    fn mget<'a, 'async_trait, K, V>(
        &'a self,
        keys: K
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<V>>>> + Send + 'async_trait>>
    where
        K: IntoArgs + Send + Sync,
        V: FromValue,
        'a: 'async_trait,
        K: 'async_trait,
        V: 'async_trait,
        Self: 'async_trait;
    fn mset<'a, 'async_trait, K, V>(
        &'a self,
        items: &'a [(K, V)]
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        K: Into<BulkString> + Send + Sync + Copy,
        V: Into<BulkString> + Send + Sync + Copy,
        'a: 'async_trait,
        K: 'async_trait,
        V: 'async_trait,
        Self: 'async_trait;
    fn msetnx<'a, 'async_trait, K, V>(
        &'a self,
        items: &'a [(K, V)]
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
    where
        K: Into<BulkString> + Send + Sync + Copy,
        V: Into<BulkString> + Send + Sync + Copy,
        'a: 'async_trait,
        K: 'async_trait,
        V: 'async_trait,
        Self: 'async_trait;
    fn psetex<'life0, 'async_trait, K, V>(
        &'life0 self,
        key: K,
        milliseconds: u64,
        value: V
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        K: Into<BulkString> + Send,
        V: Into<BulkString> + Send,
        K: 'async_trait,
        V: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;
    fn set<'life0, 'async_trait, K, V>(
        &'life0 self,
        key: K,
        value: V
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        K: Into<BulkString> + Send,
        V: Into<BulkString> + Send,
        K: 'async_trait,
        V: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;
    fn set_with_options<K, V>(&self, key: K, value: V) -> SetWithOptions<'_>
    where
        K: Into<BulkString> + Send,
        V: Into<BulkString> + Send;
    fn setex<'life0, 'async_trait, K, V>(
        &'life0 self,
        key: K,
        seconds: u64,
        value: V
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        K: Into<BulkString> + Send,
        V: Into<BulkString> + Send,
        K: 'async_trait,
        V: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;
    fn setnx<'life0, 'async_trait, K, V>(
        &'life0 self,
        key: K,
        value: V
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
    where
        K: Into<BulkString> + Send,
        V: Into<BulkString> + Send,
        K: 'async_trait,
        V: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;
    fn setrange<'life0, 'async_trait, K, V>(
        &'life0 self,
        key: K,
        offset: usize,
        value: V
    ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>
    where
        K: Into<BulkString> + Send,
        V: Into<BulkString> + Send,
        K: 'async_trait,
        V: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;
    fn strlen<'life0, 'async_trait, K>(
        &'life0 self,
        key: K
    ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>
    where
        K: Into<BulkString> + Send,
        K: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait;

}
Expand description

A group of Redis commands related to Strings

See Also

Redis Generic Commands

Required Methods

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.

Return

the length of the string after the append operation.

See Also

https://redis.io/commands/append/

Decrements the number stored at key by one.

If the key does not exist, it is set to 0 before performing the operation. An error is returned if the key contains a value of the wrong type or contains a string that can not be represented as integer. This operation is limited to 64 bit signed integers.

Return

the value of key after the decrement

See Also

https://redis.io/commands/decr/

Decrements the number stored at key by one.

If the key does not exist, it is set to 0 before performing the operation. An error is returned if the key contains a value of the wrong type or contains a string that can not be represented as integer. This operation is limited to 64 bit signed integers.

Return

the value of key after the decrement

See Also

https://redis.io/commands/decrby/

Get the value of key.

Decrements the number stored at key by decrement. If the key does not exist, it is set to 0 before performing the operation. An error is returned if the key contains a value of the wrong type or contains a string that can not be represented as integer. This operation is limited to 64 bit signed integers.

Return

the value of key, or nil when key does not exist.

See Also

https://redis.io/commands/get/

Get the value of key and delete the key.

This command is similar to GET, except for the fact that it also deletes the key on success (if and only if the key’s value type is a string).

Return

the value of key, nil when key does not exist, or an error if the key’s value type isn’t a string.

See Also

https://redis.io/commands/getdel/

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

Decrements the number stored at key by decrement. If the key does not exist, it is set to 0 before performing the operation. An error is returned if the key contains a value of the wrong type or contains a string that can not be represented as integer. This operation is limited to 64 bit signed integers.

Return

the value of key, or nil when key does not exist.

Example
ⓘ
let connection = redis::ConnectionMultiplexer::connect("127.0.0.1:6379").await?;
let database = connection.get_default_database();
let value: String = database.getex("key").ex(60).await?;
See Also

https://redis.io/commands/getex/

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

Negative offsets can be used in order to provide an offset starting from the end of the string. So -1 means the last character, -2 the penultimate and so forth.

The function handles out of range requests by limiting the resulting range to the actual length of the string.

See Also

https://redis.io/commands/getrange/

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.

Return

the old value stored at key, or nil when key did not exist.

See Also

https://redis.io/commands/getset/

Increments the number stored at key by one.

If the key does not exist, it is set to 0 before performing the operation. An error is returned if the key contains a value of the wrong type or contains a string that can not be represented as integer. This operation is limited to 64 bit signed integers.

Note: this is a string operation because Redis does not have a dedicated integer type. The string stored at the key is interpreted as a base-10 64 bit signed integer to execute the operation.

Redis stores integers in their integer representation, so for string values that actually hold an integer, there is no overhead for storing the string representation of the integer.

Return

the value of key after the increment

See Also

https://redis.io/commands/incr/

Increments the number stored at key by increment.

If the key does not exist, it is set to 0 before performing the operation. An error is returned if the key contains a value of the wrong type or contains a string that can not be represented as integer. This operation is limited to 64 bit signed integers.

See incr for extra information on increment/decrement operations.

Return

the value of key after the increment

See Also

https://redis.io/commands/incrby/

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:

  • The key contains a value of the wrong type (not a string).

  • The current key content or the specified increment are not parsable as a double precision floating point number.

If the command is successful the new incremented value is stored as the new value of the key (replacing the old one), and returned to the caller as a string.

Both the value already contained in the string key and the increment argument can be optionally provided in exponential notation, however the value computed after the increment is stored consistently in the same format, that is, an integer number followed (if needed) by a dot, and a variable number of digits representing the decimal part of the number. Trailing zeroes are always removed.

The precision of the output is fixed at 17 digits after the decimal point regardless of the actual internal precision of the computation.

Return

the value of key after the increment

See Also

https://redis.io/commands/incrbyfloat/

The LCS command implements the longest common subsequence algorithm

See Also

https://redis.io/commands/lcs/

Returns the values of all specified keys.

For every key that does not hold a string value or does not exist, the special value nil is returned. Because of this, the operation never fails.

Return

Array reply: list of values at the specified keys.

See Also

https://redis.io/commands/mget/

Sets the given keys to their respective values.

Return

always OK since MSET can’t fail.

See Also

https://redis.io/commands/mset/

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

Because of this semantic MSETNX can be used in order to set different keys representing different fields of a unique logic object in a way that ensures that either all the fields or none at all are set.

MSETNX is atomic, so all given keys are set at once. It is not possible for clients to see that some of the keys were updated while others are unchanged.

Return

specifically:

  • 1 if the all the keys were set.
  • 0 if no key was set (at least one key already existed).
See Also

https://redis.io/commands/msetnx/

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

If key already holds a value, it is overwritten, regardless of its type. Any previous time to live associated with the key is discarded on successful SET operation.

See Also

https://redis.io/commands/psetex/

Set key to hold the string value.

If key already holds a value, it is overwritten, regardless of its type. Any previous time to live associated with the key is discarded on successful SET operation.

See Also

https://redis.io/commands/set/

Set key to hold the string value.

If key already holds a value, it is overwritten, regardless of its type. Any previous time to live associated with the key is discarded on successful SET operation.

See Also

https://redis.io/commands/set/

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

See Also

https://redis.io/commands/setex/

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

In that case, it is equal to SET. When key already holds a value, no operation is performed. SETNX is short for “SET if Not eXists”.

Return

specifically:

  • true if the key was set
  • false if the key was not set
See Also

https://redis.io/commands/setnx/

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

Return

the length of the string after it was modified by the command.

See Also

https://redis.io/commands/setrange/

Returns the length of the string value stored at key.

An error is returned when key holds a non-string value.

Return

the length of the string at key, or 0 when key does not exist.

See Also

https://redis.io/commands/strlen/

Implementors