Trait GenericCommands

pub trait GenericCommands {
    // Provided methods
    fn copy<S, D>(
        &mut self,
        source: S,
        destination: D,
        destination_db: Option<usize>,
        replace: bool,
    ) -> PreparedCommand<'_, Self, bool>
       where Self: Sized,
             S: Into<CommandArg>,
             D: Into<CommandArg> { ... }
    fn del<K, C>(&mut self, keys: C) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             K: Into<CommandArg>,
             C: SingleArgOrCollection<K> { ... }
    fn dump<K>(&mut self, key: K) -> PreparedCommand<'_, Self, DumpResult>
       where Self: Sized,
             K: Into<CommandArg> { ... }
    fn exists<K, C>(&mut self, keys: C) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             K: Into<CommandArg>,
             C: SingleArgOrCollection<K> { ... }
    fn expire<K>(
        &mut self,
        key: K,
        seconds: u64,
        option: ExpireOption,
    ) -> PreparedCommand<'_, Self, bool>
       where Self: Sized,
             K: Into<CommandArg> { ... }
    fn expireat<K>(
        &mut self,
        key: K,
        unix_time_seconds: u64,
        option: ExpireOption,
    ) -> PreparedCommand<'_, Self, bool>
       where Self: Sized,
             K: Into<CommandArg> { ... }
    fn expiretime<K>(&mut self, key: K) -> PreparedCommand<'_, Self, i64>
       where Self: Sized,
             K: Into<CommandArg> { ... }
    fn keys<P, K, A>(&mut self, pattern: P) -> PreparedCommand<'_, Self, A>
       where Self: Sized,
             P: Into<CommandArg>,
             K: FromValue,
             A: FromSingleValueArray<K> { ... }
    fn migrate<H, K>(
        &mut self,
        host: H,
        port: u16,
        key: K,
        destination_db: usize,
        timeout: u64,
        options: MigrateOptions,
    ) -> PreparedCommand<'_, Self, MigrateResult>
       where Self: Sized,
             H: Into<CommandArg>,
             K: Into<CommandArg> { ... }
    fn move_<K>(&mut self, key: K, db: usize) -> PreparedCommand<'_, Self, i64>
       where Self: Sized,
             K: Into<CommandArg> { ... }
    fn object_encoding<K, E>(&mut self, key: K) -> PreparedCommand<'_, Self, E>
       where Self: Sized,
             K: Into<CommandArg>,
             E: FromValue { ... }
    fn object_freq<K>(&mut self, key: K) -> PreparedCommand<'_, Self, i64>
       where Self: Sized,
             K: Into<CommandArg> { ... }
    fn object_idle_time<K>(&mut self, key: K) -> PreparedCommand<'_, Self, i64>
       where Self: Sized,
             K: Into<CommandArg> { ... }
    fn object_refcount<K>(&mut self, key: K) -> PreparedCommand<'_, Self, i64>
       where Self: Sized,
             K: Into<CommandArg> { ... }
    fn persist<K>(&mut self, key: K) -> PreparedCommand<'_, Self, bool>
       where Self: Sized,
             K: Into<CommandArg> { ... }
    fn pexpire<K>(
        &mut self,
        key: K,
        milliseconds: u64,
        option: ExpireOption,
    ) -> PreparedCommand<'_, Self, bool>
       where Self: Sized,
             K: Into<CommandArg> { ... }
    fn pexpireat<K>(
        &mut self,
        key: K,
        unix_time_milliseconds: u64,
        option: ExpireOption,
    ) -> PreparedCommand<'_, Self, bool>
       where Self: Sized,
             K: Into<CommandArg> { ... }
    fn pexpiretime<K>(&mut self, key: K) -> PreparedCommand<'_, Self, i64>
       where Self: Sized,
             K: Into<CommandArg> { ... }
    fn pttl<K>(&mut self, key: K) -> PreparedCommand<'_, Self, i64>
       where Self: Sized,
             K: Into<CommandArg> { ... }
    fn randomkey<R>(&mut self) -> PreparedCommand<'_, Self, R>
       where Self: Sized,
             R: FromValue { ... }
    fn rename<K1, K2>(
        &mut self,
        key: K1,
        new_key: K2,
    ) -> PreparedCommand<'_, Self, ()>
       where Self: Sized,
             K1: Into<CommandArg>,
             K2: Into<CommandArg> { ... }
    fn renamenx<K1, K2>(
        &mut self,
        key: K1,
        new_key: K2,
    ) -> PreparedCommand<'_, Self, bool>
       where Self: Sized,
             K1: Into<CommandArg>,
             K2: Into<CommandArg> { ... }
    fn restore<K>(
        &mut self,
        key: K,
        ttl: u64,
        serialized_value: Vec<u8>,
        options: RestoreOptions,
    ) -> PreparedCommand<'_, Self, ()>
       where Self: Sized,
             K: Into<CommandArg> { ... }
    fn scan<K, A>(
        &mut self,
        cursor: u64,
        options: ScanOptions,
    ) -> PreparedCommand<'_, Self, (u64, A)>
       where Self: Sized,
             K: FromValue,
             A: FromSingleValueArray<K> { ... }
    fn sort<K, M, A>(
        &mut self,
        key: K,
        options: SortOptions,
    ) -> PreparedCommand<'_, Self, A>
       where Self: Sized,
             K: Into<CommandArg>,
             M: FromValue,
             A: FromSingleValueArray<M> { ... }
    fn sort_and_store<K, D>(
        &mut self,
        key: K,
        destination: D,
        options: SortOptions,
    ) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             K: Into<CommandArg>,
             D: Into<CommandArg> { ... }
    fn sort_readonly<K, M, A>(
        &mut self,
        key: K,
        options: SortOptions,
    ) -> PreparedCommand<'_, Self, A>
       where Self: Sized,
             K: Into<CommandArg>,
             M: FromValue,
             A: FromSingleValueArray<M> { ... }
    fn touch<K, KK>(&mut self, keys: KK) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             K: Into<CommandArg>,
             KK: SingleArgOrCollection<K> { ... }
    fn ttl<K>(&mut self, key: K) -> PreparedCommand<'_, Self, i64>
       where Self: Sized,
             K: Into<CommandArg> { ... }
    fn type_<K>(&mut self, key: K) -> PreparedCommand<'_, Self, String>
       where Self: Sized,
             K: Into<CommandArg> { ... }
    fn unlink<K, C>(&mut self, keys: C) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             K: Into<CommandArg>,
             C: SingleArgOrCollection<K> { ... }
    fn wait(
        &mut self,
        num_replicas: usize,
        timeout: u64,
    ) -> PreparedCommand<'_, Self, usize>
       where Self: Sized { ... }
}

A group of generic Redis commands

See Also

Redis Generic Commands

Provided Methods

fn copy<S, D>( &mut self, source: S, destination: D, destination_db: Option<usize>, replace: bool, ) -> PreparedCommand<'_, Self, bool>

where Self: Sized, S: Into<CommandArg>, D: Into<CommandArg>,

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

Return

Success of the operation

See Also

https://redis.io/commands/copy/

fn del<K, C>(&mut self, keys: C) -> PreparedCommand<'_, Self, usize>

where Self: Sized, K: Into<CommandArg>, C: SingleArgOrCollection<K>,

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

Return

The number of keys that were removed.

See Also

https://redis.io/commands/del/

fn dump<K>(&mut self, key: K) -> PreparedCommand<'_, Self, DumpResult>

where Self: Sized, K: Into<CommandArg>,

Serialize the value stored at key in a Redis-specific format and return it to the user.

Return

The serialized value.

See Also

https://redis.io/commands/dump/

fn exists<K, C>(&mut self, keys: C) -> PreparedCommand<'_, Self, usize>

where Self: Sized, K: Into<CommandArg>, C: SingleArgOrCollection<K>,

Returns if keys exist.

Return

The number of keys that exist from those specified as arguments.

See Also

https://redis.io/commands/exists/

fn expire<K>( &mut self, key: K, seconds: u64, option: ExpireOption, ) -> PreparedCommand<'_, Self, bool>

where Self: Sized, K: Into<CommandArg>,

Set a timeout on key in seconds

Return

• true - if the timeout was set.
• false - if the timeout was not set. e.g. key doesn’t exist, or operation skipped due to the provided arguments.

See Also

https://redis.io/commands/expire/

fn expireat<K>( &mut self, key: K, unix_time_seconds: u64, option: ExpireOption, ) -> PreparedCommand<'_, Self, bool>

where Self: Sized, K: Into<CommandArg>,

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)

A timestamp in the past will delete the key

Return

• true - if the timeout was set.
• false - if the timeout was not set. e.g. key doesn’t exist, or operation skipped due to the provided arguments.

See Also

https://redis.io/commands/expireat/

fn expiretime<K>(&mut self, key: K) -> PreparedCommand<'_, Self, i64>

where Self: Sized, K: Into<CommandArg>,

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

Return

Expiration Unix timestamp in seconds, or a negative value in order to signal an error (see the description below).

• The command returns -1 if the key exists but has no associated expiration time.
• The command returns -2 if the key does not exist.

See Also

https://redis.io/commands/expiretime/

fn keys<P, K, A>(&mut self, pattern: P) -> PreparedCommand<'_, Self, A>

where Self: Sized, P: Into<CommandArg>, K: FromValue, A: FromSingleValueArray<K>,

Returns all keys matching pattern.

Return

list of keys matching pattern.

See Also

https://redis.io/commands/keys/

fn migrate<H, K>( &mut self, host: H, port: u16, key: K, destination_db: usize, timeout: u64, options: MigrateOptions, ) -> PreparedCommand<'_, Self, MigrateResult>

where Self: Sized, H: Into<CommandArg>, K: Into<CommandArg>,

Atomically transfer a key or a collection of keys from a source Redis instance to a destination Redis instance.

Return

• true - on success
• false - if no keys were found in the source instance.

See Also

https://redis.io/commands/migrate/

fn move_<K>(&mut self, key: K, db: usize) -> PreparedCommand<'_, Self, i64>

where Self: Sized, K: Into<CommandArg>,

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

Return

• true - if key was moved.
• false - f key was not moved.

See Also

https://redis.io/commands/move/

fn object_encoding<K, E>(&mut self, key: K) -> PreparedCommand<'_, Self, E>

where Self: Sized, K: Into<CommandArg>, E: FromValue,

Returns the internal encoding for the Redis object stored at key

Return

The encoding of the object, or nil if the key doesn’t exist

See Also

https://redis.io/commands/object-encoding/

fn object_freq<K>(&mut self, key: K) -> PreparedCommand<'_, Self, i64>

where Self: Sized, K: Into<CommandArg>,

This command returns the logarithmic access frequency counter of a Redis object stored at key.

Return

The counter’s value.

See Also

https://redis.io/commands/object-freq/

fn object_idle_time<K>(&mut self, key: K) -> PreparedCommand<'_, Self, i64>

where Self: Sized, K: Into<CommandArg>,

This command returns the time in seconds since the last access to the value stored at key.

Return

The idle time in seconds.

See Also

https://redis.io/commands/object-idletime/

fn object_refcount<K>(&mut self, key: K) -> PreparedCommand<'_, Self, i64>

where Self: Sized, K: Into<CommandArg>,

This command returns the reference count of the stored at key.

Return

The number of references.

See Also

https://redis.io/commands/object-refcount/

fn persist<K>(&mut self, key: K) -> PreparedCommand<'_, Self, bool>

where Self: Sized, K: Into<CommandArg>,

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).

Return

• true - if the timeout was removed.
• false - if key does not exist or does not have an associated timeout.

See Also

https://redis.io/commands/persist/

fn pexpire<K>( &mut self, key: K, milliseconds: u64, option: ExpireOption, ) -> PreparedCommand<'_, Self, bool>

where Self: Sized, K: Into<CommandArg>,

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

Return

• true - if the timeout was set.
• false - if the timeout was not set. e.g. key doesn’t exist, or operation skipped due to the provided arguments.

See Also

https://redis.io/commands/pexpire/

fn pexpireat<K>( &mut self, key: K, unix_time_milliseconds: u64, option: ExpireOption, ) -> PreparedCommand<'_, Self, bool>

where Self: Sized, K: Into<CommandArg>,

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.

Return

• true - if the timeout was set.
• false - if the timeout was not set. e.g. key doesn’t exist, or operation skipped due to the provided arguments.

See Also

https://redis.io/commands/pexpireat/

fn pexpiretime<K>(&mut self, key: K) -> PreparedCommand<'_, Self, i64>

where Self: Sized, K: Into<CommandArg>,

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

Return

Expiration Unix timestamp in milliseconds, or a negative value in order to signal an error (see the description below).

• The command returns -1 if the key exists but has no associated expiration time.
• The command returns -2 if the key does not exist.

See Also

https://redis.io/commands/pexpiretime/

fn pttl<K>(&mut self, key: K) -> PreparedCommand<'_, Self, i64>

where Self: Sized, K: Into<CommandArg>,

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

Return

TTL in milliseconds, or a negative value in order to signal an error: -2 if the key does not exist. -1 if the key exists but has no associated expire.

See Also

https://redis.io/commands/pttl/

fn randomkey<R>(&mut self) -> PreparedCommand<'_, Self, R>

where Self: Sized, R: FromValue,

Return a random key from the currently selected database.

Return

The number of references.

See Also

https://redis.io/commands/randomkey/

fn rename<K1, K2>( &mut self, key: K1, new_key: K2, ) -> PreparedCommand<'_, Self, ()>

where Self: Sized, K1: Into<CommandArg>, K2: Into<CommandArg>,

Renames key to newkey.

See Also

https://redis.io/commands/rename/

fn renamenx<K1, K2>( &mut self, key: K1, new_key: K2, ) -> PreparedCommand<'_, Self, bool>

where Self: Sized, K1: Into<CommandArg>, K2: Into<CommandArg>,

Renames key to newkey if newkey does not yet exist. It returns an error when key does not exist.

Return

• true if key was renamed to newkey.
• false if newkey already exists.

See Also

https://redis.io/commands/renamenx/

fn restore<K>( &mut self, key: K, ttl: u64, serialized_value: Vec<u8>, options: RestoreOptions, ) -> PreparedCommand<'_, Self, ()>

where Self: Sized, K: Into<CommandArg>,

Create a key associated with a value that is obtained by deserializing the provided serialized value (obtained via DUMP).

Return

Restore command builder

See Also

https://redis.io/commands/restore/

fn scan<K, A>( &mut self, cursor: u64, options: ScanOptions, ) -> PreparedCommand<'_, Self, (u64, A)>

where Self: Sized, K: FromValue, A: FromSingleValueArray<K>,

Iterates the set of keys in the currently selected Redis database.

Return

A list of keys

See Also

https://redis.io/commands/scan/

fn sort<K, M, A>( &mut self, key: K, options: SortOptions, ) -> PreparedCommand<'_, Self, A>

where Self: Sized, K: Into<CommandArg>, M: FromValue, A: FromSingleValueArray<M>,

Returns the elements contained in the list, set or sorted set at key.

Return

A collection of sorted elements.

See Also

https://redis.io/commands/sort/

fn sort_and_store<K, D>( &mut self, key: K, destination: D, options: SortOptions, ) -> PreparedCommand<'_, Self, usize>

where Self: Sized, K: Into<CommandArg>, D: Into<CommandArg>,

Stores the elements contained in the list, set or sorted set at key.

Return

The number of sorted elements in the destination list.

See Also

https://redis.io/commands/sort/

fn sort_readonly<K, M, A>( &mut self, key: K, options: SortOptions, ) -> PreparedCommand<'_, Self, A>

where Self: Sized, K: Into<CommandArg>, M: FromValue, A: FromSingleValueArray<M>,

Read-only variant of the SORT command.

It is exactly like the original SORT but refuses the STORE option and can safely be used in read-only replicas.

Return

A collection of sorted elements.

See Also

https://redis.io/commands/sort_ro/

fn touch<K, KK>(&mut self, keys: KK) -> PreparedCommand<'_, Self, usize>

where Self: Sized, K: Into<CommandArg>, KK: SingleArgOrCollection<K>,

Alters the last access time of a key(s). A key is ignored if it does not exist.

Return

The number of keys that were touched.

See Also

https://redis.io/commands/touch/

fn ttl<K>(&mut self, key: K) -> PreparedCommand<'_, Self, i64>

where Self: Sized, K: Into<CommandArg>,

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

Return

TTL in seconds, or a negative value in order to signal an error: -2 if the key does not exist. -1 if the key exists but has no associated expire.

See Also

https://redis.io/commands/ttl/

fn type_<K>(&mut self, key: K) -> PreparedCommand<'_, Self, String>

where Self: Sized, K: Into<CommandArg>,

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

The different types that can be returned are: string, list, set, zset, hash and stream.

Return

type of key, or empty string when key does not exist.

See Also

https://redis.io/commands/type/

fn unlink<K, C>(&mut self, keys: C) -> PreparedCommand<'_, Self, usize>

where Self: Sized, K: Into<CommandArg>, C: SingleArgOrCollection<K>,

This command is very similar to DEL: it removes the specified keys.

Return

The number of keys that were unlinked.

See Also

https://redis.io/commands/unlink/

fn wait( &mut self, num_replicas: usize, timeout: u64, ) -> PreparedCommand<'_, Self, usize>

where Self: Sized,

This command blocks the current client until all the previous write commands are successfully transferred and acknowledged by at least the specified number of replicas.

Return

The number of replicas reached by all the writes performed in the context of the current connection.

See Also

https://redis.io/commands/wait/

Implementors

impl GenericCommands for Client

impl GenericCommands for MultiplexedClient

impl GenericCommands for Pipeline

impl GenericCommands for Transaction