pub struct Client { /* private fields */ }
Expand description
The client type.
Implementations§
source§impl Client
impl Client
The client acts as connector to the redis server. By itself it does not do much other than providing a convenient way to fetch a connection from it. In the future the plan is to provide a connection pool in the client.
When opening a client a URL in the following format should be used:
redis://host:port/db
Example usage::
let client = redis::Client::open("redis://127.0.0.1/").unwrap();
let con = client.get_connection().unwrap();
sourcepub fn open<T: IntoConnectionInfo>(params: T) -> RedisResult<Client>
pub fn open<T: IntoConnectionInfo>(params: T) -> RedisResult<Client>
Connects to a redis server and returns a client. This does not actually open a connection yet but it does perform some basic checks on the URL that might make the operation fail.
sourcepub fn get_connection(&self) -> RedisResult<Connection>
pub fn get_connection(&self) -> RedisResult<Connection>
Instructs the client to actually connect to redis and returns a connection object. The connection object can be used to send commands to the server. This can fail with a variety of errors (like unreachable host) so it’s important that you handle those errors.
sourcepub fn get_connection_with_timeout(
&self,
timeout: Duration
) -> RedisResult<Connection>
pub fn get_connection_with_timeout( &self, timeout: Duration ) -> RedisResult<Connection>
Instructs the client to actually connect to redis with specified timeout and returns a connection object. The connection object can be used to send commands to the server. This can fail with a variety of errors (like unreachable host) so it’s important that you handle those errors.
sourcepub fn get_connection_info(&self) -> &ConnectionInfo
pub fn get_connection_info(&self) -> &ConnectionInfo
Returns a reference of client connection info object.
source§impl Client
impl Client
To enable async support you need to chose one of the supported runtimes and active its
corresponding feature: tokio-comp
or async-std-comp
sourcepub async fn get_async_connection(&self) -> RedisResult<Connection>
👎Deprecated: aio::Connection is deprecated. Use client::get_multiplexed_async_connection instead.Available on crate feature aio
only.
pub async fn get_async_connection(&self) -> RedisResult<Connection>
aio
only.Returns an async connection from the client.
sourcepub async fn get_tokio_connection(&self) -> RedisResult<Connection>
👎Deprecated: aio::Connection is deprecated. Use client::get_multiplexed_tokio_connection instead.Available on crate features aio
and tokio-comp
only.
pub async fn get_tokio_connection(&self) -> RedisResult<Connection>
aio
and tokio-comp
only.Returns an async connection from the client.
sourcepub async fn get_async_std_connection(&self) -> RedisResult<Connection>
👎Deprecated: aio::Connection is deprecated. Use client::get_multiplexed_async_std_connection instead.Available on crate features aio
and async-std-comp
only.
pub async fn get_async_std_connection(&self) -> RedisResult<Connection>
aio
and async-std-comp
only.Returns an async connection from the client.
sourcepub async fn get_multiplexed_async_connection(
&self
) -> RedisResult<MultiplexedConnection>
Available on crate feature aio
and (crate features tokio-comp
or async-std-comp
) only.
pub async fn get_multiplexed_async_connection( &self ) -> RedisResult<MultiplexedConnection>
aio
and (crate features tokio-comp
or async-std-comp
) only.Returns an async connection from the client.
sourcepub async fn get_multiplexed_async_connection_with_timeouts(
&self,
response_timeout: Duration,
connection_timeout: Duration
) -> RedisResult<MultiplexedConnection>
Available on crate feature aio
and (crate features tokio-comp
or async-std-comp
) only.
pub async fn get_multiplexed_async_connection_with_timeouts( &self, response_timeout: Duration, connection_timeout: Duration ) -> RedisResult<MultiplexedConnection>
aio
and (crate features tokio-comp
or async-std-comp
) only.Returns an async connection from the client.
sourcepub async fn get_multiplexed_tokio_connection_with_response_timeouts(
&self,
response_timeout: Duration,
connection_timeout: Duration
) -> RedisResult<MultiplexedConnection>
Available on crate features aio
and tokio-comp
only.
pub async fn get_multiplexed_tokio_connection_with_response_timeouts( &self, response_timeout: Duration, connection_timeout: Duration ) -> RedisResult<MultiplexedConnection>
aio
and tokio-comp
only.Returns an async multiplexed connection from the client.
A multiplexed connection can be cloned, allowing requests to be be sent concurrently on the same underlying connection (tcp/unix socket).
sourcepub async fn get_multiplexed_tokio_connection(
&self
) -> RedisResult<MultiplexedConnection>
Available on crate features aio
and tokio-comp
only.
pub async fn get_multiplexed_tokio_connection( &self ) -> RedisResult<MultiplexedConnection>
aio
and tokio-comp
only.Returns an async multiplexed connection from the client.
A multiplexed connection can be cloned, allowing requests to be be sent concurrently on the same underlying connection (tcp/unix socket).
sourcepub async fn get_multiplexed_async_std_connection_with_timeouts(
&self,
response_timeout: Duration,
connection_timeout: Duration
) -> RedisResult<MultiplexedConnection>
Available on crate features aio
and async-std-comp
only.
pub async fn get_multiplexed_async_std_connection_with_timeouts( &self, response_timeout: Duration, connection_timeout: Duration ) -> RedisResult<MultiplexedConnection>
aio
and async-std-comp
only.Returns an async multiplexed connection from the client.
A multiplexed connection can be cloned, allowing requests to be be sent concurrently on the same underlying connection (tcp/unix socket).
sourcepub async fn get_multiplexed_async_std_connection(
&self
) -> RedisResult<MultiplexedConnection>
Available on crate features aio
and async-std-comp
only.
pub async fn get_multiplexed_async_std_connection( &self ) -> RedisResult<MultiplexedConnection>
aio
and async-std-comp
only.Returns an async multiplexed connection from the client.
A multiplexed connection can be cloned, allowing requests to be be sent concurrently on the same underlying connection (tcp/unix socket).
sourcepub async fn create_multiplexed_tokio_connection_with_response_timeout(
&self,
response_timeout: Duration
) -> RedisResult<(MultiplexedConnection, impl Future<Output = ()>)>
Available on crate features aio
and tokio-comp
only.
pub async fn create_multiplexed_tokio_connection_with_response_timeout( &self, response_timeout: Duration ) -> RedisResult<(MultiplexedConnection, impl Future<Output = ()>)>
aio
and tokio-comp
only.Returns an async multiplexed connection from the client and a future which must be polled
to drive any requests submitted to it (see get_multiplexed_tokio_connection
).
A multiplexed connection can be cloned, allowing requests to be be sent concurrently
on the same underlying connection (tcp/unix socket).
The multiplexer will return a timeout error on any request that takes longer then response_timeout
.
sourcepub async fn create_multiplexed_tokio_connection(
&self
) -> RedisResult<(MultiplexedConnection, impl Future<Output = ()>)>
Available on crate features aio
and tokio-comp
only.
pub async fn create_multiplexed_tokio_connection( &self ) -> RedisResult<(MultiplexedConnection, impl Future<Output = ()>)>
aio
and tokio-comp
only.Returns an async multiplexed connection from the client and a future which must be polled
to drive any requests submitted to it (see get_multiplexed_tokio_connection
).
A multiplexed connection can be cloned, allowing requests to be be sent concurrently on the same underlying connection (tcp/unix socket).
sourcepub async fn create_multiplexed_async_std_connection_with_response_timeout(
&self,
response_timeout: Duration
) -> RedisResult<(MultiplexedConnection, impl Future<Output = ()>)>
Available on crate features aio
and async-std-comp
only.
pub async fn create_multiplexed_async_std_connection_with_response_timeout( &self, response_timeout: Duration ) -> RedisResult<(MultiplexedConnection, impl Future<Output = ()>)>
aio
and async-std-comp
only.Returns an async multiplexed connection from the client and a future which must be polled
to drive any requests submitted to it (see get_multiplexed_tokio_connection
).
A multiplexed connection can be cloned, allowing requests to be be sent concurrently on the same underlying connection (tcp/unix socket). The multiplexer will return a timeout error on any request that takes longer then [response_timeout].
sourcepub async fn create_multiplexed_async_std_connection(
&self
) -> RedisResult<(MultiplexedConnection, impl Future<Output = ()>)>
Available on crate features aio
and async-std-comp
only.
pub async fn create_multiplexed_async_std_connection( &self ) -> RedisResult<(MultiplexedConnection, impl Future<Output = ()>)>
aio
and async-std-comp
only.Returns an async multiplexed connection from the client and a future which must be polled
to drive any requests submitted to it (see get_multiplexed_tokio_connection
).
A multiplexed connection can be cloned, allowing requests to be be sent concurrently on the same underlying connection (tcp/unix socket).
sourcepub async fn get_tokio_connection_manager(
&self
) -> RedisResult<ConnectionManager>
👎Deprecated: use get_connection_manager insteadAvailable on crate features aio
and connection-manager
only.
pub async fn get_tokio_connection_manager( &self ) -> RedisResult<ConnectionManager>
aio
and connection-manager
only.Returns an async ConnectionManager
from the client.
The connection manager wraps a
MultiplexedConnection
. If a command to that
connection fails with a connection error, then a new connection is
established in the background and the error is returned to the caller.
This means that on connection loss at least one command will fail, but
the connection will be re-established automatically if possible. Please
refer to the ConnectionManager
docs for
detailed reconnecting behavior.
A connection manager can be cloned, allowing requests to be be sent concurrently on the same underlying connection (tcp/unix socket).
sourcepub async fn get_connection_manager(&self) -> RedisResult<ConnectionManager>
Available on crate features aio
and connection-manager
only.
pub async fn get_connection_manager(&self) -> RedisResult<ConnectionManager>
aio
and connection-manager
only.Returns an async ConnectionManager
from the client.
The connection manager wraps a
MultiplexedConnection
. If a command to that
connection fails with a connection error, then a new connection is
established in the background and the error is returned to the caller.
This means that on connection loss at least one command will fail, but
the connection will be re-established automatically if possible. Please
refer to the ConnectionManager
docs for
detailed reconnecting behavior.
A connection manager can be cloned, allowing requests to be be sent concurrently on the same underlying connection (tcp/unix socket).
sourcepub async fn get_tokio_connection_manager_with_backoff(
&self,
exponent_base: u64,
factor: u64,
number_of_retries: usize
) -> RedisResult<ConnectionManager>
👎Deprecated: use get_connection_manager_with_backoff insteadAvailable on crate features aio
and connection-manager
only.
pub async fn get_tokio_connection_manager_with_backoff( &self, exponent_base: u64, factor: u64, number_of_retries: usize ) -> RedisResult<ConnectionManager>
aio
and connection-manager
only.Returns an async ConnectionManager
from the client.
The connection manager wraps a
MultiplexedConnection
. If a command to that
connection fails with a connection error, then a new connection is
established in the background and the error is returned to the caller.
This means that on connection loss at least one command will fail, but
the connection will be re-established automatically if possible. Please
refer to the ConnectionManager
docs for
detailed reconnecting behavior.
A connection manager can be cloned, allowing requests to be be sent concurrently on the same underlying connection (tcp/unix socket).
sourcepub async fn get_tokio_connection_manager_with_backoff_and_timeouts(
&self,
exponent_base: u64,
factor: u64,
number_of_retries: usize,
response_timeout: Duration,
connection_timeout: Duration
) -> RedisResult<ConnectionManager>
Available on crate features aio
and connection-manager
only.
pub async fn get_tokio_connection_manager_with_backoff_and_timeouts( &self, exponent_base: u64, factor: u64, number_of_retries: usize, response_timeout: Duration, connection_timeout: Duration ) -> RedisResult<ConnectionManager>
aio
and connection-manager
only.Returns an async ConnectionManager
from the client.
The connection manager wraps a
MultiplexedConnection
. If a command to that
connection fails with a connection error, then a new connection is
established in the background and the error is returned to the caller.
This means that on connection loss at least one command will fail, but
the connection will be re-established automatically if possible. Please
refer to the ConnectionManager
docs for
detailed reconnecting behavior.
A connection manager can be cloned, allowing requests to be be sent concurrently on the same underlying connection (tcp/unix socket).
sourcepub async fn get_connection_manager_with_backoff(
&self,
exponent_base: u64,
factor: u64,
number_of_retries: usize
) -> RedisResult<ConnectionManager>
Available on crate features aio
and connection-manager
only.
pub async fn get_connection_manager_with_backoff( &self, exponent_base: u64, factor: u64, number_of_retries: usize ) -> RedisResult<ConnectionManager>
aio
and connection-manager
only.Returns an async ConnectionManager
from the client.
The connection manager wraps a
MultiplexedConnection
. If a command to that
connection fails with a connection error, then a new connection is
established in the background and the error is returned to the caller.
This means that on connection loss at least one command will fail, but
the connection will be re-established automatically if possible. Please
refer to the ConnectionManager
docs for
detailed reconnecting behavior.
A connection manager can be cloned, allowing requests to be be sent concurrently on the same underlying connection (tcp/unix socket).
sourcepub fn build_with_tls<C: IntoConnectionInfo>(
conn_info: C,
tls_certs: TlsCertificates
) -> RedisResult<Client>
Available on crate feature aio
only.
pub fn build_with_tls<C: IntoConnectionInfo>( conn_info: C, tls_certs: TlsCertificates ) -> RedisResult<Client>
aio
only.Constructs a new Client
with parameters necessary to create a TLS connection.
conn_info
- URL using therediss://
scheme.tls_certs
-TlsCertificates
structure containing: –client_tls
- OptionalClientTlsConfig
containing byte streams for —client_cert
- client’s byte stream containing client certificate in PEM format —client_key
- client’s byte stream containing private key in PEM format –root_cert
- Optional byte stream yielding PEM formatted file for root certificates.
If ClientTlsConfig
( cert+key pair ) is not provided, then client-side authentication is not enabled.
If root_cert
is not provided, then system root certificates are used instead.
§Examples
use std::{fs::File, io::{BufReader, Read}};
use redis::{Client, AsyncCommands as _, TlsCertificates, ClientTlsConfig};
async fn do_redis_code(
url: &str,
root_cert_file: &str,
cert_file: &str,
key_file: &str
) -> redis::RedisResult<()> {
let root_cert_file = File::open(root_cert_file).expect("cannot open private cert file");
let mut root_cert_vec = Vec::new();
BufReader::new(root_cert_file)
.read_to_end(&mut root_cert_vec)
.expect("Unable to read ROOT cert file");
let cert_file = File::open(cert_file).expect("cannot open private cert file");
let mut client_cert_vec = Vec::new();
BufReader::new(cert_file)
.read_to_end(&mut client_cert_vec)
.expect("Unable to read client cert file");
let key_file = File::open(key_file).expect("cannot open private key file");
let mut client_key_vec = Vec::new();
BufReader::new(key_file)
.read_to_end(&mut client_key_vec)
.expect("Unable to read client key file");
let client = Client::build_with_tls(
url,
TlsCertificates {
client_tls: Some(ClientTlsConfig{
client_cert: client_cert_vec,
client_key: client_key_vec,
}),
root_cert: Some(root_cert_vec),
}
)
.expect("Unable to build client");
let connection_info = client.get_connection_info();
println!(">>> connection info: {connection_info:?}");
let mut con = client.get_async_connection().await?;
con.set("key1", b"foo").await?;
redis::cmd("SET")
.arg(&["key2", "bar"])
.query_async(&mut con)
.await?;
let result = redis::cmd("MGET")
.arg(&["key1", "key2"])
.query_async(&mut con)
.await;
assert_eq!(result, Ok(("foo".to_string(), b"bar".to_vec())));
println!("Result from MGET: {result:?}");
Ok(())
}
sourcepub async fn get_async_pubsub(&self) -> RedisResult<PubSub>
Available on crate feature aio
only.
pub async fn get_async_pubsub(&self) -> RedisResult<PubSub>
aio
only.Returns an async receiver for pub-sub messages.
sourcepub async fn get_async_monitor(&self) -> RedisResult<Monitor>
Available on crate feature aio
only.
pub async fn get_async_monitor(&self) -> RedisResult<Monitor>
aio
only.Returns an async receiver for monitor messages.
Trait Implementations§
source§impl ConnectionLike for Client
impl ConnectionLike for Client
source§fn req_packed_command(&mut self, cmd: &[u8]) -> RedisResult<Value>
fn req_packed_command(&mut self, cmd: &[u8]) -> RedisResult<Value>
source§fn get_db(&self) -> i64
fn get_db(&self) -> i64
source§fn check_connection(&mut self) -> bool
fn check_connection(&mut self) -> bool
PING
internally).source§fn req_command(&mut self, cmd: &Cmd) -> RedisResult<Value>
fn req_command(&mut self, cmd: &Cmd) -> RedisResult<Value>
source§impl ManageConnection for Client
Available on crate feature r2d2
only.
impl ManageConnection for Client
r2d2
only.§type Connection = Connection
type Connection = Connection
§type Error = RedisError
type Error = RedisError
Connection
s.source§fn connect(&self) -> Result<Self::Connection, Self::Error>
fn connect(&self) -> Result<Self::Connection, Self::Error>
source§fn is_valid(&self, conn: &mut Self::Connection) -> Result<(), Self::Error>
fn is_valid(&self, conn: &mut Self::Connection) -> Result<(), Self::Error>
source§fn has_broken(&self, conn: &mut Self::Connection) -> bool
fn has_broken(&self, conn: &mut Self::Connection) -> bool
Auto Trait Implementations§
impl Freeze for Client
impl RefUnwindSafe for Client
impl Send for Client
impl Sync for Client
impl Unpin for Client
impl UnwindSafe for Client
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> Commands for Twhere
T: ConnectionLike,
impl<T> Commands for Twhere
T: ConnectionLike,
source§fn get<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn get<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
MGET
.source§fn mget<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn mget<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn keys<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn keys<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn set<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V
) -> RedisResult<RV>
fn set<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V ) -> RedisResult<RV>
source§fn set_options<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
options: SetOptions
) -> RedisResult<RV>
fn set_options<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, options: SetOptions ) -> RedisResult<RV>
source§fn set_multiple<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
items: &'a [(K, V)]
) -> RedisResult<RV>
fn set_multiple<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, items: &'a [(K, V)] ) -> RedisResult<RV>
source§fn mset<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
items: &'a [(K, V)]
) -> RedisResult<RV>
fn mset<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, items: &'a [(K, V)] ) -> RedisResult<RV>
source§fn set_ex<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
seconds: u64
) -> RedisResult<RV>
fn set_ex<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, seconds: u64 ) -> RedisResult<RV>
source§fn pset_ex<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
milliseconds: u64
) -> RedisResult<RV>
fn pset_ex<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, milliseconds: u64 ) -> RedisResult<RV>
source§fn set_nx<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V
) -> RedisResult<RV>
fn set_nx<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V ) -> RedisResult<RV>
source§fn mset_nx<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
items: &'a [(K, V)]
) -> RedisResult<RV>
fn mset_nx<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, items: &'a [(K, V)] ) -> RedisResult<RV>
source§fn getset<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V
) -> RedisResult<RV>
fn getset<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V ) -> RedisResult<RV>
source§fn getrange<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
from: isize,
to: isize
) -> RedisResult<RV>
fn getrange<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, from: isize, to: isize ) -> RedisResult<RV>
source§fn setrange<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
offset: isize,
value: V
) -> RedisResult<RV>
fn setrange<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, offset: isize, value: V ) -> RedisResult<RV>
source§fn del<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn del<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn exists<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn exists<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn key_type<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn key_type<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn expire<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
seconds: i64
) -> RedisResult<RV>
fn expire<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, seconds: i64 ) -> RedisResult<RV>
source§fn expire_at<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
ts: i64
) -> RedisResult<RV>
fn expire_at<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ts: i64 ) -> RedisResult<RV>
source§fn pexpire<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
ms: i64
) -> RedisResult<RV>
fn pexpire<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ms: i64 ) -> RedisResult<RV>
source§fn pexpire_at<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
ts: i64
) -> RedisResult<RV>
fn pexpire_at<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ts: i64 ) -> RedisResult<RV>
source§fn persist<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn persist<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn ttl<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn ttl<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn pttl<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn pttl<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn get_ex<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
expire_at: Expiry
) -> RedisResult<RV>
fn get_ex<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, expire_at: Expiry ) -> RedisResult<RV>
source§fn get_del<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn get_del<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn rename<'a, K: ToRedisArgs, N: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
new_key: N
) -> RedisResult<RV>
fn rename<'a, K: ToRedisArgs, N: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, new_key: N ) -> RedisResult<RV>
source§fn rename_nx<'a, K: ToRedisArgs, N: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
new_key: N
) -> RedisResult<RV>
fn rename_nx<'a, K: ToRedisArgs, N: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, new_key: N ) -> RedisResult<RV>
source§fn unlink<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn unlink<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn append<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V
) -> RedisResult<RV>
fn append<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V ) -> RedisResult<RV>
source§fn incr<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
delta: V
) -> RedisResult<RV>
fn incr<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, delta: V ) -> RedisResult<RV>
INCRBY
or INCRBYFLOAT
depending on the type.source§fn decr<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
delta: V
) -> RedisResult<RV>
fn decr<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, delta: V ) -> RedisResult<RV>
source§fn setbit<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
offset: usize,
value: bool
) -> RedisResult<RV>
fn setbit<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, offset: usize, value: bool ) -> RedisResult<RV>
source§fn getbit<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
offset: usize
) -> RedisResult<RV>
fn getbit<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, offset: usize ) -> RedisResult<RV>
source§fn bitcount<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn bitcount<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn bitcount_range<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: usize,
end: usize
) -> RedisResult<RV>
fn bitcount_range<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: usize, end: usize ) -> RedisResult<RV>
source§fn bit_and<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
srckeys: S
) -> RedisResult<RV>
fn bit_and<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, srckeys: S ) -> RedisResult<RV>
source§fn bit_or<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
srckeys: S
) -> RedisResult<RV>
fn bit_or<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, srckeys: S ) -> RedisResult<RV>
source§fn bit_xor<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
srckeys: S
) -> RedisResult<RV>
fn bit_xor<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, srckeys: S ) -> RedisResult<RV>
source§fn bit_not<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
srckey: S
) -> RedisResult<RV>
fn bit_not<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, srckey: S ) -> RedisResult<RV>
source§fn strlen<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn strlen<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn hget<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
field: F
) -> RedisResult<RV>
fn hget<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, field: F ) -> RedisResult<RV>
source§fn hdel<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
field: F
) -> RedisResult<RV>
fn hdel<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, field: F ) -> RedisResult<RV>
source§fn hset<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
field: F,
value: V
) -> RedisResult<RV>
fn hset<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, field: F, value: V ) -> RedisResult<RV>
source§fn hset_nx<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
field: F,
value: V
) -> RedisResult<RV>
fn hset_nx<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, field: F, value: V ) -> RedisResult<RV>
source§fn hset_multiple<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
items: &'a [(F, V)]
) -> RedisResult<RV>
fn hset_multiple<'a, K: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, items: &'a [(F, V)] ) -> RedisResult<RV>
source§fn hincr<'a, K: ToRedisArgs, F: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
field: F,
delta: D
) -> RedisResult<RV>
fn hincr<'a, K: ToRedisArgs, F: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, field: F, delta: D ) -> RedisResult<RV>
source§fn hexists<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
field: F
) -> RedisResult<RV>
fn hexists<'a, K: ToRedisArgs, F: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, field: F ) -> RedisResult<RV>
source§fn hkeys<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn hkeys<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn hvals<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn hvals<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn hgetall<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn hgetall<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn hlen<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn hlen<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn blmove<'a, S: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
timeout: f64
) -> RedisResult<RV>
fn blmove<'a, S: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>( &mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, timeout: f64 ) -> RedisResult<RV>
source§fn blmpop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
timeout: f64,
numkeys: usize,
key: K,
dir: Direction,
count: usize
) -> RedisResult<RV>
fn blmpop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, timeout: f64, numkeys: usize, key: K, dir: Direction, count: usize ) -> RedisResult<RV>
count
elements from the first non-empty list key from the list of
provided key names; or blocks until one is available.source§fn blpop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
timeout: f64
) -> RedisResult<RV>
fn blpop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, timeout: f64 ) -> RedisResult<RV>
source§fn brpop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
timeout: f64
) -> RedisResult<RV>
fn brpop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, timeout: f64 ) -> RedisResult<RV>
source§fn brpoplpush<'a, S: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&mut self,
srckey: S,
dstkey: D,
timeout: f64
) -> RedisResult<RV>
fn brpoplpush<'a, S: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>( &mut self, srckey: S, dstkey: D, timeout: f64 ) -> RedisResult<RV>
source§fn lindex<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
index: isize
) -> RedisResult<RV>
fn lindex<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, index: isize ) -> RedisResult<RV>
source§fn linsert_before<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
pivot: P,
value: V
) -> RedisResult<RV>
fn linsert_before<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pivot: P, value: V ) -> RedisResult<RV>
source§fn linsert_after<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
pivot: P,
value: V
) -> RedisResult<RV>
fn linsert_after<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pivot: P, value: V ) -> RedisResult<RV>
source§fn llen<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn llen<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn lmove<'a, S: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction
) -> RedisResult<RV>
fn lmove<'a, S: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>( &mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction ) -> RedisResult<RV>
source§fn lmpop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
numkeys: usize,
key: K,
dir: Direction,
count: usize
) -> RedisResult<RV>
fn lmpop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, numkeys: usize, key: K, dir: Direction, count: usize ) -> RedisResult<RV>
count
elements from the first non-empty list key from the list of
provided key names.source§fn lpop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: Option<NonZeroUsize>
) -> RedisResult<RV>
fn lpop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: Option<NonZeroUsize> ) -> RedisResult<RV>
count
first elements of the list stored at key. Read moresource§fn lpos<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V,
options: LposOptions
) -> RedisResult<RV>
fn lpos<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V, options: LposOptions ) -> RedisResult<RV>
source§fn lpush<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V
) -> RedisResult<RV>
fn lpush<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V ) -> RedisResult<RV>
source§fn lpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V
) -> RedisResult<RV>
fn lpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V ) -> RedisResult<RV>
source§fn lrange<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn lrange<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize ) -> RedisResult<RV>
source§fn lrem<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: isize,
value: V
) -> RedisResult<RV>
fn lrem<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: isize, value: V ) -> RedisResult<RV>
source§fn ltrim<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn ltrim<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize ) -> RedisResult<RV>
source§fn lset<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
index: isize,
value: V
) -> RedisResult<RV>
fn lset<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, index: isize, value: V ) -> RedisResult<RV>
source§fn rpop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: Option<NonZeroUsize>
) -> RedisResult<RV>
fn rpop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: Option<NonZeroUsize> ) -> RedisResult<RV>
count
last elements of the list stored at key Read moresource§fn rpoplpush<'a, K: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
dstkey: D
) -> RedisResult<RV>
fn rpoplpush<'a, K: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, dstkey: D ) -> RedisResult<RV>
source§fn rpush<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V
) -> RedisResult<RV>
fn rpush<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V ) -> RedisResult<RV>
source§fn rpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
value: V
) -> RedisResult<RV>
fn rpush_exists<'a, K: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, value: V ) -> RedisResult<RV>
source§fn sadd<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M
) -> RedisResult<RV>
fn sadd<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M ) -> RedisResult<RV>
source§fn scard<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn scard<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn sdiff<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: K
) -> RedisResult<RV>
fn sdiff<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: K ) -> RedisResult<RV>
source§fn sdiffstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: K
) -> RedisResult<RV>
fn sdiffstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: K ) -> RedisResult<RV>
source§fn sinter<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: K
) -> RedisResult<RV>
fn sinter<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: K ) -> RedisResult<RV>
source§fn sinterstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: K
) -> RedisResult<RV>
fn sinterstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: K ) -> RedisResult<RV>
source§fn sismember<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M
) -> RedisResult<RV>
fn sismember<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M ) -> RedisResult<RV>
source§fn smismember<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
members: M
) -> RedisResult<RV>
fn smismember<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, members: M ) -> RedisResult<RV>
source§fn smembers<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn smembers<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn smove<'a, S: ToRedisArgs, D: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
srckey: S,
dstkey: D,
member: M
) -> RedisResult<RV>
fn smove<'a, S: ToRedisArgs, D: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, srckey: S, dstkey: D, member: M ) -> RedisResult<RV>
source§fn spop<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn spop<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn srandmember<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn srandmember<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn srandmember_multiple<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: usize
) -> RedisResult<RV>
fn srandmember_multiple<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: usize ) -> RedisResult<RV>
source§fn srem<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M
) -> RedisResult<RV>
fn srem<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M ) -> RedisResult<RV>
source§fn sunion<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: K
) -> RedisResult<RV>
fn sunion<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: K ) -> RedisResult<RV>
source§fn sunionstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: K
) -> RedisResult<RV>
fn sunionstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: K ) -> RedisResult<RV>
source§fn zadd<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M,
score: S
) -> RedisResult<RV>
fn zadd<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M, score: S ) -> RedisResult<RV>
source§fn zadd_multiple<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
items: &'a [(S, M)]
) -> RedisResult<RV>
fn zadd_multiple<'a, K: ToRedisArgs, S: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, items: &'a [(S, M)] ) -> RedisResult<RV>
source§fn zcard<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn zcard<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn zcount<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zcount<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM ) -> RedisResult<RV>
source§fn zincr<'a, K: ToRedisArgs, M: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M,
delta: D
) -> RedisResult<RV>
fn zincr<'a, K: ToRedisArgs, M: ToRedisArgs, D: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M, delta: D ) -> RedisResult<RV>
source§fn zinterstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [K]
) -> RedisResult<RV>
fn zinterstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [K] ) -> RedisResult<RV>
source§fn zinterstore_min<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [K]
) -> RedisResult<RV>
fn zinterstore_min<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [K] ) -> RedisResult<RV>
source§fn zinterstore_max<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [K]
) -> RedisResult<RV>
fn zinterstore_max<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [K] ) -> RedisResult<RV>
source§fn zinterstore_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [(K, W)]
) -> RedisResult<RV>
fn zinterstore_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [(K, W)] ) -> RedisResult<RV>
Commands::zinterstore
, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.source§fn zinterstore_min_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [(K, W)]
) -> RedisResult<RV>
fn zinterstore_min_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [(K, W)] ) -> RedisResult<RV>
Commands::zinterstore_min
, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.source§fn zinterstore_max_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [(K, W)]
) -> RedisResult<RV>
fn zinterstore_max_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [(K, W)] ) -> RedisResult<RV>
Commands::zinterstore_max
, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.source§fn zlexcount<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zlexcount<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM ) -> RedisResult<RV>
source§fn bzpopmax<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
timeout: f64
) -> RedisResult<RV>
fn bzpopmax<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, timeout: f64 ) -> RedisResult<RV>
source§fn zpopmax<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: isize
) -> RedisResult<RV>
fn zpopmax<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: isize ) -> RedisResult<RV>
source§fn bzpopmin<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
timeout: f64
) -> RedisResult<RV>
fn bzpopmin<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, timeout: f64 ) -> RedisResult<RV>
source§fn zpopmin<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: isize
) -> RedisResult<RV>
fn zpopmin<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: isize ) -> RedisResult<RV>
source§fn bzmpop_max<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
timeout: f64,
keys: &'a [K],
count: isize
) -> RedisResult<RV>
fn bzmpop_max<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, timeout: f64, keys: &'a [K], count: isize ) -> RedisResult<RV>
source§fn zmpop_max<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: &'a [K],
count: isize
) -> RedisResult<RV>
fn zmpop_max<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: &'a [K], count: isize ) -> RedisResult<RV>
source§fn bzmpop_min<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
timeout: f64,
keys: &'a [K],
count: isize
) -> RedisResult<RV>
fn bzmpop_min<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, timeout: f64, keys: &'a [K], count: isize ) -> RedisResult<RV>
source§fn zmpop_min<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: &'a [K],
count: isize
) -> RedisResult<RV>
fn zmpop_min<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: &'a [K], count: isize ) -> RedisResult<RV>
source§fn zrandmember<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: Option<isize>
) -> RedisResult<RV>
fn zrandmember<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: Option<isize> ) -> RedisResult<RV>
count == None
)source§fn zrandmember_withscores<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
count: isize
) -> RedisResult<RV>
fn zrandmember_withscores<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, count: isize ) -> RedisResult<RV>
source§fn zrange<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn zrange<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize ) -> RedisResult<RV>
source§fn zrange_withscores<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn zrange_withscores<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize ) -> RedisResult<RV>
source§fn zrangebylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zrangebylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM ) -> RedisResult<RV>
source§fn zrangebylex_limit<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> RedisResult<RV>
fn zrangebylex_limit<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize ) -> RedisResult<RV>
source§fn zrevrangebylex<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
max: MM,
min: M
) -> RedisResult<RV>
fn zrevrangebylex<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, max: MM, min: M ) -> RedisResult<RV>
source§fn zrevrangebylex_limit<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> RedisResult<RV>
fn zrevrangebylex_limit<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize ) -> RedisResult<RV>
source§fn zrangebyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zrangebyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM ) -> RedisResult<RV>
source§fn zrangebyscore_withscores<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zrangebyscore_withscores<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM ) -> RedisResult<RV>
source§fn zrangebyscore_limit<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> RedisResult<RV>
fn zrangebyscore_limit<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize ) -> RedisResult<RV>
source§fn zrangebyscore_limit_withscores<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> RedisResult<RV>
fn zrangebyscore_limit_withscores<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize ) -> RedisResult<RV>
source§fn zrank<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M
) -> RedisResult<RV>
fn zrank<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M ) -> RedisResult<RV>
source§fn zrem<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
members: M
) -> RedisResult<RV>
fn zrem<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, members: M ) -> RedisResult<RV>
source§fn zrembylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zrembylex<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM ) -> RedisResult<RV>
source§fn zremrangebyrank<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn zremrangebyrank<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize ) -> RedisResult<RV>
source§fn zrembyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
min: M,
max: MM
) -> RedisResult<RV>
fn zrembyscore<'a, K: ToRedisArgs, M: ToRedisArgs, MM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, min: M, max: MM ) -> RedisResult<RV>
source§fn zrevrange<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn zrevrange<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize ) -> RedisResult<RV>
source§fn zrevrange_withscores<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: isize,
stop: isize
) -> RedisResult<RV>
fn zrevrange_withscores<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: isize, stop: isize ) -> RedisResult<RV>
source§fn zrevrangebyscore<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
max: MM,
min: M
) -> RedisResult<RV>
fn zrevrangebyscore<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, max: MM, min: M ) -> RedisResult<RV>
source§fn zrevrangebyscore_withscores<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
max: MM,
min: M
) -> RedisResult<RV>
fn zrevrangebyscore_withscores<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, max: MM, min: M ) -> RedisResult<RV>
source§fn zrevrangebyscore_limit<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> RedisResult<RV>
fn zrevrangebyscore_limit<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize ) -> RedisResult<RV>
source§fn zrevrangebyscore_limit_withscores<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> RedisResult<RV>
fn zrevrangebyscore_limit_withscores<'a, K: ToRedisArgs, MM: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize ) -> RedisResult<RV>
source§fn zrevrank<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M
) -> RedisResult<RV>
fn zrevrank<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M ) -> RedisResult<RV>
source§fn zscore<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M
) -> RedisResult<RV>
fn zscore<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M ) -> RedisResult<RV>
source§fn zscore_multiple<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
members: &'a [M]
) -> RedisResult<RV>
fn zscore_multiple<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, members: &'a [M] ) -> RedisResult<RV>
source§fn zunionstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [K]
) -> RedisResult<RV>
fn zunionstore<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [K] ) -> RedisResult<RV>
source§fn zunionstore_min<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [K]
) -> RedisResult<RV>
fn zunionstore_min<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [K] ) -> RedisResult<RV>
source§fn zunionstore_max<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [K]
) -> RedisResult<RV>
fn zunionstore_max<'a, D: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [K] ) -> RedisResult<RV>
source§fn zunionstore_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [(K, W)]
) -> RedisResult<RV>
fn zunionstore_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [(K, W)] ) -> RedisResult<RV>
Commands::zunionstore
, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.source§fn zunionstore_min_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [(K, W)]
) -> RedisResult<RV>
fn zunionstore_min_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [(K, W)] ) -> RedisResult<RV>
Commands::zunionstore_min
, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.source§fn zunionstore_max_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
keys: &'a [(K, W)]
) -> RedisResult<RV>
fn zunionstore_max_weights<'a, D: ToRedisArgs, K: ToRedisArgs, W: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, keys: &'a [(K, W)] ) -> RedisResult<RV>
Commands::zunionstore_max
, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.source§fn pfadd<'a, K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
element: E
) -> RedisResult<RV>
fn pfadd<'a, K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, element: E ) -> RedisResult<RV>
source§fn pfcount<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn pfcount<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn pfmerge<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
dstkey: D,
srckeys: S
) -> RedisResult<RV>
fn pfmerge<'a, D: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, dstkey: D, srckeys: S ) -> RedisResult<RV>
source§fn publish<'a, K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>(
&mut self,
channel: K,
message: E
) -> RedisResult<RV>
fn publish<'a, K: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>( &mut self, channel: K, message: E ) -> RedisResult<RV>
source§fn object_encoding<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn object_encoding<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn object_idletime<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn object_idletime<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn object_freq<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn object_freq<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn object_refcount<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn object_refcount<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn acl_load<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_load<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
acl
only.source§fn acl_save<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_save<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
acl
only.source§fn acl_list<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_list<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
acl
only.source§fn acl_users<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_users<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
acl
only.source§fn acl_getuser<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
username: K
) -> RedisResult<RV>
fn acl_getuser<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, username: K ) -> RedisResult<RV>
acl
only.source§fn acl_setuser<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
username: K
) -> RedisResult<RV>
fn acl_setuser<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, username: K ) -> RedisResult<RV>
acl
only.source§fn acl_setuser_rules<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
username: K,
rules: &'a [Rule]
) -> RedisResult<RV>
fn acl_setuser_rules<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, username: K, rules: &'a [Rule] ) -> RedisResult<RV>
acl
only.source§fn acl_deluser<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
usernames: &'a [K]
) -> RedisResult<RV>
fn acl_deluser<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, usernames: &'a [K] ) -> RedisResult<RV>
acl
only.source§fn acl_cat<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_cat<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
acl
only.source§fn acl_cat_categoryname<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
categoryname: K
) -> RedisResult<RV>
fn acl_cat_categoryname<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, categoryname: K ) -> RedisResult<RV>
acl
only.source§fn acl_genpass<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_genpass<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
acl
only.source§fn acl_genpass_bits<'a, RV: FromRedisValue>(
&mut self,
bits: isize
) -> RedisResult<RV>
fn acl_genpass_bits<'a, RV: FromRedisValue>( &mut self, bits: isize ) -> RedisResult<RV>
acl
only.source§fn acl_whoami<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_whoami<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
acl
only.source§fn acl_log<'a, RV: FromRedisValue>(&mut self, count: isize) -> RedisResult<RV>
fn acl_log<'a, RV: FromRedisValue>(&mut self, count: isize) -> RedisResult<RV>
acl
only.source§fn acl_log_reset<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_log_reset<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
acl
only.source§fn acl_help<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
fn acl_help<'a, RV: FromRedisValue>(&mut self) -> RedisResult<RV>
acl
only.source§fn geo_add<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
members: M
) -> RedisResult<RV>
fn geo_add<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, members: M ) -> RedisResult<RV>
geospatial
only.source§fn geo_dist<'a, K: ToRedisArgs, M1: ToRedisArgs, M2: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member1: M1,
member2: M2,
unit: Unit
) -> RedisResult<RV>
fn geo_dist<'a, K: ToRedisArgs, M1: ToRedisArgs, M2: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member1: M1, member2: M2, unit: Unit ) -> RedisResult<RV>
geospatial
only.source§fn geo_hash<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
members: M
) -> RedisResult<RV>
fn geo_hash<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, members: M ) -> RedisResult<RV>
geospatial
only.source§fn geo_pos<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
members: M
) -> RedisResult<RV>
fn geo_pos<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, members: M ) -> RedisResult<RV>
geospatial
only.source§fn geo_radius<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
longitude: f64,
latitude: f64,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> RedisResult<RV>
fn geo_radius<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, longitude: f64, latitude: f64, radius: f64, unit: Unit, options: RadiusOptions ) -> RedisResult<RV>
geospatial
only.source§fn geo_radius_by_member<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
member: M,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> RedisResult<RV>
fn geo_radius_by_member<'a, K: ToRedisArgs, M: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, member: M, radius: f64, unit: Unit, options: RadiusOptions ) -> RedisResult<RV>
geospatial
only.member
. The
member itself is always contained in the results.source§fn xack<'a, K: ToRedisArgs, G: ToRedisArgs, I: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
ids: &'a [I]
) -> RedisResult<RV>
fn xack<'a, K: ToRedisArgs, G: ToRedisArgs, I: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, ids: &'a [I] ) -> RedisResult<RV>
streams
only.source§fn xadd<'a, K: ToRedisArgs, ID: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
id: ID,
items: &'a [(F, V)]
) -> RedisResult<RV>
fn xadd<'a, K: ToRedisArgs, ID: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, id: ID, items: &'a [(F, V)] ) -> RedisResult<RV>
streams
only.source§fn xadd_map<'a, K: ToRedisArgs, ID: ToRedisArgs, BTM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
id: ID,
map: BTM
) -> RedisResult<RV>
fn xadd_map<'a, K: ToRedisArgs, ID: ToRedisArgs, BTM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, id: ID, map: BTM ) -> RedisResult<RV>
streams
only.key
.
Use *
as the id
for the current timestamp. Read moresource§fn xadd_maxlen<'a, K: ToRedisArgs, ID: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
items: &'a [(F, V)]
) -> RedisResult<RV>
fn xadd_maxlen<'a, K: ToRedisArgs, ID: ToRedisArgs, F: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, maxlen: StreamMaxlen, id: ID, items: &'a [(F, V)] ) -> RedisResult<RV>
streams
only.source§fn xadd_maxlen_map<'a, K: ToRedisArgs, ID: ToRedisArgs, BTM: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
map: BTM
) -> RedisResult<RV>
fn xadd_maxlen_map<'a, K: ToRedisArgs, ID: ToRedisArgs, BTM: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, maxlen: StreamMaxlen, id: ID, map: BTM ) -> RedisResult<RV>
streams
only.source§fn xclaim<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, MIT: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID]
) -> RedisResult<RV>
fn xclaim<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, MIT: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, consumer: C, min_idle_time: MIT, ids: &'a [ID] ) -> RedisResult<RV>
streams
only.source§fn xclaim_options<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, MIT: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID],
options: StreamClaimOptions
) -> RedisResult<RV>
fn xclaim_options<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, MIT: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, consumer: C, min_idle_time: MIT, ids: &'a [ID], options: StreamClaimOptions ) -> RedisResult<RV>
streams
only.source§fn xdel<'a, K: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
ids: &'a [ID]
) -> RedisResult<RV>
fn xdel<'a, K: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, ids: &'a [ID] ) -> RedisResult<RV>
streams
only.source§fn xgroup_create<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
id: ID
) -> RedisResult<RV>
fn xgroup_create<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, id: ID ) -> RedisResult<RV>
streams
only.group
. It expects the stream key
to already exist. Otherwise, use xgroup_create_mkstream
if it doesn’t.
The id
is the starting message id all consumers should read from. Use $
If you want
all consumers to read from the last message added to stream. Read moresource§fn xgroup_create_mkstream<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
id: ID
) -> RedisResult<RV>
fn xgroup_create_mkstream<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, id: ID ) -> RedisResult<RV>
streams
only.group
which makes the stream if it doesn’t exist. Read moresource§fn xgroup_setid<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
id: ID
) -> RedisResult<RV>
fn xgroup_setid<'a, K: ToRedisArgs, G: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, id: ID ) -> RedisResult<RV>
streams
only.source§fn xgroup_destroy<'a, K: ToRedisArgs, G: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G
) -> RedisResult<RV>
fn xgroup_destroy<'a, K: ToRedisArgs, G: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G ) -> RedisResult<RV>
streams
only.source§fn xgroup_delconsumer<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
consumer: C
) -> RedisResult<RV>
fn xgroup_delconsumer<'a, K: ToRedisArgs, G: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, consumer: C ) -> RedisResult<RV>
streams
only.source§fn xinfo_consumers<'a, K: ToRedisArgs, G: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G
) -> RedisResult<RV>
fn xinfo_consumers<'a, K: ToRedisArgs, G: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G ) -> RedisResult<RV>
streams
only.group
.
Take note of the StreamInfoConsumersReply return type. Read moresource§fn xinfo_groups<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn xinfo_groups<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
streams
only.group
s created for a given stream key
.
Take note of the StreamInfoGroupsReply return type. Read moresource§fn xinfo_stream<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn xinfo_stream<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
streams
only.id
, length, number of groups, etc.)
Take note of the StreamInfoStreamReply return type. Read moresource§fn xlen<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn xlen<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
streams
only.key
. Read moresource§fn xpending<'a, K: ToRedisArgs, G: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G
) -> RedisResult<RV>
fn xpending<'a, K: ToRedisArgs, G: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G ) -> RedisResult<RV>
streams
only.key
and consumer group
and it
returns details about which consumers have pending messages
that haven’t been acked. Read moresource§fn xpending_count<'a, K: ToRedisArgs, G: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
start: S,
end: E,
count: C
) -> RedisResult<RV>
fn xpending_count<'a, K: ToRedisArgs, G: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, start: S, end: E, count: C ) -> RedisResult<RV>
streams
only.source§fn xpending_consumer_count<'a, K: ToRedisArgs, G: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs, CN: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
group: G,
start: S,
end: E,
count: C,
consumer: CN
) -> RedisResult<RV>
fn xpending_consumer_count<'a, K: ToRedisArgs, G: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs, CN: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, group: G, start: S, end: E, count: C, consumer: CN ) -> RedisResult<RV>
streams
only.source§fn xrange<'a, K: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: S,
end: E
) -> RedisResult<RV>
fn xrange<'a, K: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: S, end: E ) -> RedisResult<RV>
streams
only.key
. Read moresource§fn xrange_all<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn xrange_all<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
streams
only.key
.
Use with caution! Read moresource§fn xrange_count<'a, K: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
start: S,
end: E,
count: C
) -> RedisResult<RV>
fn xrange_count<'a, K: ToRedisArgs, S: ToRedisArgs, E: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, start: S, end: E, count: C ) -> RedisResult<RV>
streams
only.key
. Read moresource§fn xread<'a, K: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: &'a [K],
ids: &'a [ID]
) -> RedisResult<RV>
fn xread<'a, K: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: &'a [K], ids: &'a [ID] ) -> RedisResult<RV>
streams
only.id
s for each stream key
.
This is the basic form of reading streams.
For more advanced control, like blocking, limiting, or reading by consumer group
,
see xread_options
. Read moresource§fn xread_options<'a, K: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>(
&mut self,
keys: &'a [K],
ids: &'a [ID],
options: &'a StreamReadOptions
) -> RedisResult<RV>
fn xread_options<'a, K: ToRedisArgs, ID: ToRedisArgs, RV: FromRedisValue>( &mut self, keys: &'a [K], ids: &'a [ID], options: &'a StreamReadOptions ) -> RedisResult<RV>
streams
only.source§fn xrevrange<'a, K: ToRedisArgs, E: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
end: E,
start: S
) -> RedisResult<RV>
fn xrevrange<'a, K: ToRedisArgs, E: ToRedisArgs, S: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, end: E, start: S ) -> RedisResult<RV>
streams
only.source§fn xrevrange_all<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<RV>
fn xrevrange_all<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<RV>
source§fn xrevrange_count<'a, K: ToRedisArgs, E: ToRedisArgs, S: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
end: E,
start: S,
count: C
) -> RedisResult<RV>
fn xrevrange_count<'a, K: ToRedisArgs, E: ToRedisArgs, S: ToRedisArgs, C: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, end: E, start: S, count: C ) -> RedisResult<RV>
streams
only.source§fn xtrim<'a, K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
maxlen: StreamMaxlen
) -> RedisResult<RV>
fn xtrim<'a, K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, maxlen: StreamMaxlen ) -> RedisResult<RV>
streams
only.key
to a MAXLEN count. Read moresource§fn scan<RV: FromRedisValue>(&mut self) -> RedisResult<Iter<'_, RV>>
fn scan<RV: FromRedisValue>(&mut self) -> RedisResult<Iter<'_, RV>>
source§fn scan_match<P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
pattern: P
) -> RedisResult<Iter<'_, RV>>
fn scan_match<P: ToRedisArgs, RV: FromRedisValue>( &mut self, pattern: P ) -> RedisResult<Iter<'_, RV>>
source§fn hscan<K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<Iter<'_, RV>>
fn hscan<K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<Iter<'_, RV>>
source§fn hscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
pattern: P
) -> RedisResult<Iter<'_, RV>>
fn hscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pattern: P ) -> RedisResult<Iter<'_, RV>>
source§fn sscan<K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<Iter<'_, RV>>
fn sscan<K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<Iter<'_, RV>>
source§fn sscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
pattern: P
) -> RedisResult<Iter<'_, RV>>
fn sscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pattern: P ) -> RedisResult<Iter<'_, RV>>
source§fn zscan<K: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K
) -> RedisResult<Iter<'_, RV>>
fn zscan<K: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K ) -> RedisResult<Iter<'_, RV>>
source§fn zscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
pattern: P
) -> RedisResult<Iter<'_, RV>>
fn zscan_match<K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, pattern: P ) -> RedisResult<Iter<'_, RV>>
source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> JsonCommands for Twhere
T: ConnectionLike,
impl<T> JsonCommands for Twhere
T: ConnectionLike,
source§fn json_arr_append<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>(
&mut self,
key: K,
path: P,
value: &'a V
) -> RedisResult<RV>
fn json_arr_append<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>( &mut self, key: K, path: P, value: &'a V ) -> RedisResult<RV>
json
only.value
to the array at path
after the last element in it.source§fn json_arr_index<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>(
&mut self,
key: K,
path: P,
value: &'a V
) -> RedisResult<RV>
fn json_arr_index<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>( &mut self, key: K, path: P, value: &'a V ) -> RedisResult<RV>
json
only.path
, returns first occurance of value
source§fn json_arr_index_ss<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>(
&mut self,
key: K,
path: P,
value: &'a V,
start: &'a isize,
stop: &'a isize
) -> RedisResult<RV>
fn json_arr_index_ss<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>( &mut self, key: K, path: P, value: &'a V, start: &'a isize, stop: &'a isize ) -> RedisResult<RV>
json
only.json_arr_index
except takes a start
and a stop
value, setting these to 0
will mean
they make no effect on the query Read moresource§fn json_arr_insert<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>(
&mut self,
key: K,
path: P,
index: i64,
value: &'a V
) -> RedisResult<RV>
fn json_arr_insert<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>( &mut self, key: K, path: P, index: i64, value: &'a V ) -> RedisResult<RV>
json
only.source§fn json_arr_len<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P
) -> RedisResult<RV>
fn json_arr_len<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P ) -> RedisResult<RV>
json
only.path
in key
.source§fn json_arr_pop<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P,
index: i64
) -> RedisResult<RV>
fn json_arr_pop<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P, index: i64 ) -> RedisResult<RV>
json
only.index
in the array. Read moresource§fn json_arr_trim<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P,
start: i64,
stop: i64
) -> RedisResult<RV>
fn json_arr_trim<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P, start: i64, stop: i64 ) -> RedisResult<RV>
json
only.source§fn json_clear<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P
) -> RedisResult<RV>
fn json_clear<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P ) -> RedisResult<RV>
json
only.source§fn json_del<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P
) -> RedisResult<RV>
fn json_del<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P ) -> RedisResult<RV>
json
only.path
.source§fn json_get<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P
) -> RedisResult<RV>
fn json_get<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P ) -> RedisResult<RV>
json
only.path
. Read moresource§fn json_num_incr_by<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P,
value: i64
) -> RedisResult<RV>
fn json_num_incr_by<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P, value: i64 ) -> RedisResult<RV>
json
only.path
by number
.source§fn json_obj_keys<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P
) -> RedisResult<RV>
fn json_obj_keys<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P ) -> RedisResult<RV>
json
only.path
.source§fn json_obj_len<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P
) -> RedisResult<RV>
fn json_obj_len<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P ) -> RedisResult<RV>
json
only.path
in key
.source§fn json_set<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>(
&mut self,
key: K,
path: P,
value: &'a V
) -> RedisResult<RV>
fn json_set<'a, K: ToRedisArgs, P: ToRedisArgs, V: Serialize, RV: FromRedisValue>( &mut self, key: K, path: P, value: &'a V ) -> RedisResult<RV>
json
only.path
in key
.source§fn json_str_append<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P,
value: V
) -> RedisResult<RV>
fn json_str_append<'a, K: ToRedisArgs, P: ToRedisArgs, V: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P, value: V ) -> RedisResult<RV>
json
only.json-string
values to the string at path
.source§fn json_str_len<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P
) -> RedisResult<RV>
fn json_str_len<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P ) -> RedisResult<RV>
json
only.path
in key
.source§fn json_toggle<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P
) -> RedisResult<RV>
fn json_toggle<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P ) -> RedisResult<RV>
json
only.boolean
value stored at path
.source§fn json_type<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>(
&mut self,
key: K,
path: P
) -> RedisResult<RV>
fn json_type<'a, K: ToRedisArgs, P: ToRedisArgs, RV: FromRedisValue>( &mut self, key: K, path: P ) -> RedisResult<RV>
json
only.path
.