main
use redis::{AsyncCommands, FromRedisValue, ToRedisArgs, ToSingleRedisArg};
use crate::error::{CacheError, CacheResult};
use crate::kv::Cache;
impl Cache {
pub async fn zadd<M: ToSingleRedisArg + Send + Sync, S: ToSingleRedisArg + Send + Sync>(
&self,
key: &str,
member: M,
score: S,
) -> CacheResult<usize> {
let mut conn = self.conn().clone();
conn.zadd(key, member, score)
.await
.map_err(CacheError::from)
}
pub async fn zrem<M: ToRedisArgs + Send + Sync>(
&self,
key: &str,
members: M,
) -> CacheResult<usize> {
let mut conn = self.conn().clone();
conn.zrem(key, members).await.map_err(CacheError::from)
}
pub async fn zscore<M: ToSingleRedisArg + Send + Sync>(
&self,
key: &str,
member: M,
) -> CacheResult<Option<f64>> {
let mut conn = self.conn().clone();
conn.zscore(key, member).await.map_err(CacheError::from)
}
pub async fn zincr<M: ToSingleRedisArg + Send + Sync>(
&self,
key: &str,
member: M,
delta: f64,
) -> CacheResult<f64> {
let mut conn = self.conn().clone();
conn.zincr(key, member, delta)
.await
.map_err(CacheError::from)
}
pub async fn zcard(&self, key: &str) -> CacheResult<usize> {
let mut conn = self.conn().clone();
conn.zcard(key).await.map_err(CacheError::from)
}
pub async fn zcount<M: ToSingleRedisArg + Send + Sync, MM: ToSingleRedisArg + Send + Sync>(
&self,
key: &str,
min: M,
max: MM,
) -> CacheResult<usize> {
let mut conn = self.conn().clone();
conn.zcount(key, min, max).await.map_err(CacheError::from)
}
pub async fn zrange<T: FromRedisValue + Send>(
&self,
key: &str,
start: isize,
stop: isize,
) -> CacheResult<Vec<T>> {
let mut conn = self.conn().clone();
conn.zrange(key, start, stop)
.await
.map_err(CacheError::from)
}
pub async fn zrange_withscores<T: FromRedisValue + Send>(
&self,
key: &str,
start: isize,
stop: isize,
) -> CacheResult<Vec<(T, f64)>> {
let mut conn = self.conn().clone();
conn.zrange_withscores(key, start, stop)
.await
.map_err(CacheError::from)
}
pub async fn zrevrange<T: FromRedisValue + Send>(
&self,
key: &str,
start: isize,
stop: isize,
) -> CacheResult<Vec<T>> {
let mut conn = self.conn().clone();
conn.zrevrange(key, start, stop)
.await
.map_err(CacheError::from)
}
pub async fn zrevrange_withscores<T: FromRedisValue + Send>(
&self,
key: &str,
start: isize,
stop: isize,
) -> CacheResult<Vec<(T, f64)>> {
let mut conn = self.conn().clone();
conn.zrevrange_withscores(key, start, stop)
.await
.map_err(CacheError::from)
}
pub async fn zrangebyscore<
T: FromRedisValue + Send,
M: ToSingleRedisArg + Send + Sync,
MM: ToSingleRedisArg + Send + Sync,
>(
&self,
key: &str,
min: M,
max: MM,
) -> CacheResult<Vec<T>> {
let mut conn = self.conn().clone();
conn.zrangebyscore(key, min, max)
.await
.map_err(CacheError::from)
}
pub async fn zrangebyscore_withscores<
T: FromRedisValue + Send,
M: ToSingleRedisArg + Send + Sync,
MM: ToSingleRedisArg + Send + Sync,
>(
&self,
key: &str,
min: M,
max: MM,
) -> CacheResult<Vec<(T, f64)>> {
let mut conn = self.conn().clone();
conn.zrangebyscore_withscores(key, min, max)
.await
.map_err(CacheError::from)
}
pub async fn zrank<M: ToSingleRedisArg + Send + Sync>(
&self,
key: &str,
member: M,
) -> CacheResult<Option<usize>> {
let mut conn = self.conn().clone();
conn.zrank(key, member).await.map_err(CacheError::from)
}
pub async fn zrevrank<M: ToSingleRedisArg + Send + Sync>(
&self,
key: &str,
member: M,
) -> CacheResult<Option<usize>> {
let mut conn = self.conn().clone();
conn.zrevrank(key, member).await.map_err(CacheError::from)
}
}