58775d4
ZhenYi
refactor: update database write logic and normalize API paths for improved clarity and consistency
58775d4
use redis::{AsyncCommands, Cmd, FromRedisValue, ToRedisArgs, ToSingleRedisArg};
use crate::error::{CacheError, CacheResult};
use crate::kv::Cache;
impl Cache {
pub async fn sadd<V: ToRedisArgs + Send + Sync>(
&self,
key: &str,
member: V,
) -> CacheResult<usize> {
let mut conn = self.conn().clone();
conn.sadd(key, member).await.map_err(CacheError::from)
}
pub async fn sadd_many<V: ToRedisArgs + Send + Sync>(
&self,
key: &str,
members: Vec<V>,
) -> CacheResult<usize> {
let mut conn = self.conn().clone();
conn.sadd(key, members).await.map_err(CacheError::from)
}
pub async fn srem<V: ToRedisArgs + Send + Sync>(
&self,
key: &str,
members: V,
) -> CacheResult<usize> {
let mut conn = self.conn().clone();
conn.srem(key, members).await.map_err(CacheError::from)
}
pub async fn smove<V: ToRedisArgs + Send + Sync>(
&self,
source: &str,
destination: &str,
member: V,
) -> CacheResult<bool> {
let mut cmd = Cmd::new();
cmd.arg("SMOVE").arg(source).arg(destination).arg(member);
self.exec(&cmd).await
}
pub async fn sismember<M: ToSingleRedisArg + Send + Sync>(
&self,
key: &str,
member: M,
) -> CacheResult<bool> {
let mut conn = self.conn().clone();
conn.sismember(key, member).await.map_err(CacheError::from)
}
pub async fn smembers<T: FromRedisValue + Send>(&self, key: &str) -> CacheResult<Vec<T>> {
let mut conn = self.conn().clone();
conn.smembers(key).await.map_err(CacheError::from)
}
pub async fn scard(&self, key: &str) -> CacheResult<usize> {
let mut conn = self.conn().clone();
conn.scard(key).await.map_err(CacheError::from)
}
pub async fn sinter<T: FromRedisValue + Send, K: ToRedisArgs + Send + Sync>(
&self,
keys: K,
) -> CacheResult<Vec<T>> {
let mut conn = self.conn().clone();
conn.sinter(keys).await.map_err(CacheError::from)
}
pub async fn sunion<T: FromRedisValue + Send, K: ToRedisArgs + Send + Sync>(
&self,
keys: K,
) -> CacheResult<Vec<T>> {
let mut conn = self.conn().clone();
conn.sunion(keys).await.map_err(CacheError::from)
}
pub async fn sdiff<T: FromRedisValue + Send, K: ToRedisArgs + Send + Sync>(
&self,
keys: K,
) -> CacheResult<Vec<T>> {
let mut conn = self.conn().clone();
conn.sdiff(keys).await.map_err(CacheError::from)
}
pub async fn spop<T: FromRedisValue + Send>(&self, key: &str) -> CacheResult<Option<T>> {
let mut conn = self.conn().clone();
conn.spop(key).await.map_err(CacheError::from)
}
pub async fn spop_many<T: FromRedisValue + Send>(
&self,
key: &str,
count: usize,
) -> CacheResult<Vec<T>> {
let mut cmd = Cmd::new();
cmd.arg("SPOP").arg(key).arg(count);
self.exec(&cmd).await
}
}