use std::collections::HashMap;
use std::marker::PhantomData;
use std::sync::Arc;
use serde::de::DeserializeOwned;
use serde::Serialize;
use super::query::Query;
use super::{DataType, DocMeta, RedisDocument};
use crate::client::RedisClient;
use crate::error::{NasaRedisError, Result};
pub const INIT_OR_APPEND: &str = r#"if redis.call('EXISTS', KEYS[1]) == 0 then
redis.call('JSON.SET', KEYS[1], '$', '[' .. table.concat(ARGV, ',') .. ']')
else
for i = 1, #ARGV do
redis.call('JSON.ARRAPPEND', KEYS[1], '$', ARGV[i])
end
end
return #ARGV
"#;
pub const REPLACE_OR_APPEND: &str = r#"if redis.call('EXISTS', KEYS[1]) == 1 then
redis.call('JSON.DEL', KEYS[1], ARGV[1])
end
if redis.call('EXISTS', KEYS[1]) == 0 then
redis.call('JSON.SET', KEYS[1], '$', '[' .. ARGV[2] .. ']')
else
redis.call('JSON.ARRAPPEND', KEYS[1], '$', ARGV[2])
end
return 1
"#;
pub const MULTI_GET: &str = r#"local out = {}
for i = 1, #KEYS do
if redis.call('EXISTS', KEYS[i]) == 1 then
local s = redis.call('JSON.GET', KEYS[i], ARGV[1])
if s and s ~= '[]' and s ~= 'null' then
out[#out+1] = s
end
end
end
return out
"#;
pub const MULTI_DEL: &str = r#"local total = 0
for i = 1, #KEYS do
if redis.call('EXISTS', KEYS[i]) == 1 then
local n = redis.call('JSON.DEL', KEYS[i], ARGV[1])
if n then total = total + n end
end
end
return total
"#;
pub const MULTI_COUNT: &str = r#"local total = 0
for i = 1, #KEYS do
if redis.call('EXISTS', KEYS[i]) == 1 then
local s = redis.call('JSON.GET', KEYS[i], ARGV[1])
if s and s ~= '[]' and s ~= 'null' then
local arr = cjson.decode(s)
total = total + #arr
end
end
end
return total
"#;
pub struct JsonArrayOps<T: RedisDocument> {
client: Arc<RedisClient>,
meta: &'static DocMeta,
init_or_append: redis::Script,
replace_or_append: redis::Script,
multi_get: redis::Script,
multi_del: redis::Script,
multi_count: redis::Script,
_t: PhantomData<T>,
}
impl<T: RedisDocument + Serialize + DeserializeOwned> JsonArrayOps<T> {
pub async fn bind(client: Arc<RedisClient>) -> Result<Self> {
let meta = T::meta();
meta.validate()?;
if !meta.data_type.is_array() {
return Err(NasaRedisError::Config(format!(
"{} 不是 ARRAY 模式(得到 {:?})—— JsonArrayOps 仅适用 JsonArray/JsonArrayBucket",
meta.index, meta.data_type
)));
}
let js: std::result::Result<redis::Value, _> = redis::cmd("JSON.TYPE")
.arg("__nasa_capability_check__")
.query_async(&mut client.conn())
.await;
if let Err(e) = js {
if e.to_string().contains("unknown command") {
return Err(NasaRedisError::Config(format!(
"RedisJSON 模块不可用(ARRAY 模式需要):{e}"
)));
}
return Err(e.into());
}
Ok(Self {
client,
meta,
init_or_append: redis::Script::new(INIT_OR_APPEND),
replace_or_append: redis::Script::new(REPLACE_OR_APPEND),
multi_get: redis::Script::new(MULTI_GET),
multi_del: redis::Script::new(MULTI_DEL),
multi_count: redis::Script::new(MULTI_COUNT),
_t: PhantomData,
})
}
pub fn meta(&self) -> &'static DocMeta {
self.meta
}
pub async fn save(&self, doc: &T) -> Result<()> {
let parts = doc.array_key_parts();
let refs: Vec<&str> = parts.iter().map(|s| s.as_str()).collect();
let key = self.meta.array_key_for(&refs, &doc.id())?;
let body = super::to_json_omit_null(doc)?;
let _: i64 = self
.init_or_append
.key(&key)
.arg(&body)
.invoke_async(&mut self.client.conn())
.await?;
Ok(())
}
pub async fn save_all(&self, docs: &[T]) -> Result<usize> {
let mut grouped: HashMap<String, Vec<String>> = HashMap::new();
for doc in docs {
let parts = doc.array_key_parts();
let refs: Vec<&str> = parts.iter().map(|s| s.as_str()).collect();
let key = self.meta.array_key_for(&refs, &doc.id())?;
let body = super::to_json_omit_null(doc)?;
grouped.entry(key).or_default().push(body);
}
let total = docs.len();
let groups: Vec<(String, Vec<String>)> = grouped.into_iter().collect();
if groups.is_empty() {
return Ok(0);
}
let chunk_sz = self.client.config().pipeline.session_max_commands.max(1);
for chunk in groups.chunks(chunk_sz) {
let mut sess = self.client.pipeline();
let mut tickets = Vec::with_capacity(chunk.len());
for (key, bodies) in chunk {
let mut cmd = redis::cmd("EVAL");
cmd.arg(INIT_OR_APPEND).arg(1).arg(key.as_str());
for b in bodies {
cmd.arg(b.as_str());
}
tickets.push(sess.enqueue::<redis::Value>(cmd)?);
}
sess.execute().await?;
for t in tickets {
t.await_result()?;
}
}
Ok(total)
}
pub async fn save_or_replace(&self, doc: &T) -> Result<()> {
let parts = doc.array_key_parts();
let refs: Vec<&str> = parts.iter().map(|s| s.as_str()).collect();
let key = self.meta.array_key_for(&refs, &doc.id())?;
let filter = self.id_filter(&doc.id())?;
let body = super::to_json_omit_null(doc)?;
let _: i64 = self
.replace_or_append
.key(&key)
.arg(&filter)
.arg(&body)
.invoke_async(&mut self.client.conn())
.await?;
Ok(())
}
pub async fn find_sub_doc(&self, parts: &[&str], sub_id: &str) -> Result<Option<T>> {
let key = self.key_for_sub_doc(parts, sub_id)?;
let filter = self.id_filter(sub_id)?;
let mut rows: Vec<T> = self.json_get_entities(&key, &filter).await?;
Ok(if rows.is_empty() {
None
} else {
Some(rows.swap_remove(0))
})
}
pub async fn exists_sub_doc(&self, parts: &[&str], sub_id: &str) -> Result<bool> {
let key = self.key_for_sub_doc(parts, sub_id)?;
let filter = self.id_filter(sub_id)?;
Ok(chunk_non_empty(
self.json_get_chunk(&key, &filter).await?.as_deref(),
))
}
pub async fn remove_sub_doc(&self, parts: &[&str], sub_id: &str) -> Result<u64> {
let key = self.key_for_sub_doc(parts, sub_id)?;
let filter = self.id_filter(sub_id)?;
self.json_del(&key, &filter).await
}
pub async fn find_in_array(&self, parts: &[&str], q: &Query) -> Result<Vec<T>> {
let filter = q.render_json_path_filter(self.meta)?;
if self.meta.data_type == DataType::JsonArrayBucket {
let keys = self.meta.all_bucket_keys(parts)?;
let chunks = self.eval_multi_get(&keys, &filter).await?;
let mut out = Vec::new();
for chunk in &chunks {
if chunk_non_empty(Some(chunk)) {
let mut rows: Vec<T> = serde_json::from_str(chunk)
.map_err(|e| NasaRedisError::Codec(format!("JSON 解码失败: {e}")))?;
out.append(&mut rows);
}
}
return Ok(out);
}
let key = self.meta.array_key_of(parts)?;
self.json_get_entities(&key, &filter).await
}
pub async fn remove_in_array(&self, parts: &[&str], q: &Query) -> Result<u64> {
let filter = q.render_json_path_filter(self.meta)?;
if self.meta.data_type == DataType::JsonArrayBucket {
let keys = self.meta.all_bucket_keys(parts)?;
let keyrefs: Vec<&str> = keys.iter().map(|s| s.as_str()).collect();
let n: i64 = self
.invoke_multi(&self.multi_del, &keyrefs, &filter)
.await?;
return Ok(n.max(0) as u64);
}
self.json_del(&self.meta.array_key_of(parts)?, &filter)
.await
}
pub async fn count_in_array(&self, parts: &[&str], q: &Query) -> Result<u64> {
let filter = q.render_json_path_filter(self.meta)?;
if self.meta.data_type == DataType::JsonArrayBucket {
let keys = self.meta.all_bucket_keys(parts)?;
let keyrefs: Vec<&str> = keys.iter().map(|s| s.as_str()).collect();
let n: i64 = self
.invoke_multi(&self.multi_count, &keyrefs, &filter)
.await?;
return Ok(n.max(0) as u64);
}
let chunk = self
.json_get_chunk(&self.meta.array_key_of(parts)?, &filter)
.await?;
match chunk.as_deref() {
Some(s) if chunk_non_empty(Some(s)) => {
let arr: serde_json::Value = serde_json::from_str(s)
.map_err(|e| NasaRedisError::Codec(format!("JSON 解码失败: {e}")))?;
Ok(arr.as_array().map(|a| a.len()).unwrap_or(0) as u64)
}
_ => Ok(0),
}
}
fn key_for_sub_doc(&self, parts: &[&str], sub_id: &str) -> Result<String> {
match self.meta.data_type {
DataType::JsonArrayBucket => self.meta.bucket_key(parts, sub_id),
_ => self.meta.array_key_of(parts),
}
}
fn id_filter(&self, sub_id: &str) -> Result<String> {
let lit = if self.meta.id_numeric {
if let Ok(n) = sub_id.parse::<i64>() {
n.to_string()
} else {
let v: f64 = sub_id.parse().map_err(|_| {
NasaRedisError::Config(format!(
"id_numeric=true 但 subId \"{sub_id}\" 不是数字"
))
})?;
if !v.is_finite() {
return Err(NasaRedisError::Config(
"JSONPath 数值必须有限(NaN/Infinity 非法)".into(),
));
}
format!("{v}") }
} else {
super::query::json_path_literal(sub_id)?
};
Ok(format!("$[?(@.{}=={})]", self.meta.id_name, lit))
}
async fn json_get_chunk(&self, key: &str, filter: &str) -> Result<Option<String>> {
let raw: Option<String> = redis::cmd("JSON.GET")
.arg(key)
.arg(filter)
.query_async(&mut self.client.conn())
.await?;
Ok(raw)
}
async fn json_get_entities(&self, key: &str, filter: &str) -> Result<Vec<T>> {
let chunk = self.json_get_chunk(key, filter).await?;
match chunk.as_deref() {
Some(s) if chunk_non_empty(Some(s)) => serde_json::from_str(s)
.map_err(|e| NasaRedisError::Codec(format!("JSON 解码失败: {e}"))),
_ => Ok(Vec::new()),
}
}
async fn json_del(&self, key: &str, filter: &str) -> Result<u64> {
let n: i64 = redis::cmd("JSON.DEL")
.arg(key)
.arg(filter)
.query_async(&mut self.client.conn())
.await?;
Ok(n.max(0) as u64)
}
async fn eval_multi_get(&self, keys: &[String], filter: &str) -> Result<Vec<String>> {
let mut inv = self.multi_get.prepare_invoke();
for k in keys {
inv.key(k.as_str());
}
inv.arg(filter);
let chunks: Vec<String> = inv.invoke_async(&mut self.client.conn()).await?;
Ok(chunks)
}
async fn invoke_multi(
&self,
script: &redis::Script,
keys: &[&str],
filter: &str,
) -> Result<i64> {
let mut inv = script.prepare_invoke();
for k in keys {
inv.key(*k);
}
inv.arg(filter);
let n: i64 = inv.invoke_async(&mut self.client.conn()).await?;
Ok(n)
}
}
fn chunk_non_empty(chunk: Option<&str>) -> bool {
matches!(chunk, Some(s) if !s.is_empty() && s != "[]" && s != "null")
}