f2e745a
use redis::{AsyncCommands, Cmd, 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 zadd_many<M: ToRedisArgs + Send + Sync>(
&self,
key: &str,
items: &[(f64, M)],
) -> CacheResult<usize> {
let mut cmd = Cmd::new();
cmd.arg("ZADD").arg(key);
for (score, member) in items {
cmd.arg(*score).arg(member);
}
self.exec(&cmd).await
}
pub async fn zadd_nx<M: ToRedisArgs + Send + Sync>(
&self,
key: &str,
member: M,
score: f64,
) -> CacheResult<usize> {
let mut cmd = Cmd::new();
cmd.arg("ZADD").arg(key).arg("NX").arg(score).arg(member);
self.exec(&cmd).await
}
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)
}
pub async fn zremrangebyscore<
M: ToSingleRedisArg + Send + Sync,
MM: ToSingleRedisArg + Send + Sync,
>(
&self,
key: &str,
min: M,
max: MM,
) -> CacheResult<usize> {
let mut cmd = Cmd::new();
cmd.arg("ZREMRANGEBYSCORE").arg(key).arg(min).arg(max);
self.exec(&cmd).await
}
}