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#"-- 非数组根的追加可能返回空结果,覆盖还可能删除对象成员,必须在任何写入前拒绝。
local root_type = redis.call('JSON.TYPE', KEYS[1])
if root_type and root_type ~= 'array' then
return redis.error_reply('ARRAY root must be an array')
end
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#"-- 非数组根的追加可能返回空结果,覆盖还可能删除对象成员,必须在任何写入前拒绝。
local root_type = redis.call('JSON.TYPE', KEYS[1])
if root_type and root_type ~= 'array' then
return redis.error_reply('ARRAY root must be an array')
end
if type(ARGV[3]) ~= 'string' then
return redis.error_reply('ARRAY identity guard is required')
end
-- 大整数与已有浮点身份比较可能合并相邻值;同一脚本先检查全部命中类型,避免误删后才发现歧义。
if root_type and ARGV[3] ~= '' then
local id_types = redis.call('JSON.TYPE', KEYS[1], ARGV[3])
if type(id_types) ~= 'table' then
return redis.error_reply('ARRAY identity types are unavailable')
end
for i = 1, #id_types do
if id_types[i] ~= 'integer' then
return redis.error_reply('ARRAY large integer identity matches a non-integer value')
end
end
end
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
"#;
const REMOVE_INTEGER_ID: &str = r#"local root_type = redis.call('JSON.TYPE', KEYS[1])
if not root_type then
return 0
end
if root_type ~= 'array' then
return redis.error_reply('ARRAY root must be an array')
end
if type(ARGV[2]) ~= 'string' or ARGV[2] == '' then
return redis.error_reply('ARRAY integer identity path is required')
end
-- 类型复验与删除不能分成两个请求,否则检查之后出现的浮点身份仍可能被删除。
local id_types = redis.call('JSON.TYPE', KEYS[1], ARGV[2])
if type(id_types) ~= 'table' then
return redis.error_reply('ARRAY identity types are unavailable')
end
for i = 1, #id_types do
if id_types[i] ~= 'integer' then
return redis.error_reply('ARRAY large integer identity matches a non-integer value')
end
end
return redis.call('JSON.DEL', KEYS[1], ARGV[1])
"#;
const READ_INTEGER_ID: &str = r#"local root_type = redis.call('JSON.TYPE', KEYS[1])
if not root_type then
return false
end
if root_type ~= 'array' then
return redis.error_reply('ARRAY root must be an array')
end
if type(ARGV[2]) ~= 'string' or ARGV[2] == '' then
return redis.error_reply('ARRAY integer identity path is required')
end
-- 类型复验与读取不能分成两个请求,否则检查之后出现的浮点身份仍可能被当作目标文档。
local id_types = redis.call('JSON.TYPE', KEYS[1], ARGV[2])
if type(id_types) ~= 'table' then
return redis.error_reply('ARRAY identity types are unavailable')
end
for i = 1, #id_types do
if id_types[i] ~= 'integer' then
return redis.error_reply('ARRAY large integer identity matches a non-integer value')
end
end
return redis.call('JSON.GET', KEYS[1], ARGV[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;
let reply = match js {
Ok(reply) => reply,
Err(e) => {
if e.to_string().contains("unknown command") {
return Err(NasaRedisError::Config(format!(
"RedisJSON 模块不可用(ARRAY 模式需要):{e}"
)));
}
return Err(e.into());
}
};
let info = redis::IntoConnectionInfo::into_connection_info(client.config().url.as_str())?;
let reply = match (info.redis_settings().protocol(), reply) {
(redis::ProtocolVersion::RESP2, reply) => reply,
(redis::ProtocolVersion::RESP3, redis::Value::Array(mut values))
if values.len() == 1 =>
{
values.pop().expect("length checked")
}
_ => {
return Err(NasaRedisError::Codec(
"ARRAY JSON.TYPE 回复形状不符合连接协议".into(),
));
}
};
let valid = match reply {
redis::Value::Nil => true,
redis::Value::BulkString(value) => matches!(
value.as_slice(),
b"null" | b"boolean" | b"integer" | b"number" | b"string" | b"object" | b"array"
),
_ => false,
};
if !valid {
return Err(NasaRedisError::Codec(
"ARRAY JSON.TYPE 未返回已知根类型".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 id = doc.id();
if self.meta.id_numeric {
self.id_filter(&id)?;
}
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, &id)?;
let body = encode_array_document(doc, self.meta, &id)?;
let reply: redis::Value = self
.init_or_append
.key(&key)
.arg(&body)
.invoke_async(&mut self.client.conn())
.await?;
check_array_count_reply(reply, Some(1))?;
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 id = doc.id();
if self.meta.id_numeric {
self.id_filter(&id)?;
}
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, &id)?;
let body = encode_array_document(doc, self.meta, &id)?;
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)?, bodies.len()));
}
sess.execute().await?;
for (ticket, expected) in tickets {
check_array_count_reply(ticket.await_result()?, Some(expected))?;
}
}
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 id = doc.id();
let key = self.meta.array_key_for(&refs, &id)?;
let filter = self.id_filter(&id)?;
let guard_path = self.large_integer_guard_path(&id, &filter)?;
let body = encode_array_document(doc, self.meta, &id)?;
let reply: redis::Value = self
.replace_or_append
.key(&key)
.arg(&filter)
.arg(&body)
.arg(&guard_path)
.invoke_async(&mut self.client.conn())
.await?;
check_array_count_reply(reply, Some(1))?;
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 chunk = self.json_get_identity_chunk(&key, sub_id, &filter).await?;
let mut rows: Vec<T> = decode_array_chunk(chunk.as_deref())?;
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)?;
let chunk = self.json_get_identity_chunk(&key, sub_id, &filter).await?;
Ok(!decode_array_chunk::<serde_json::Value>(chunk.as_deref())?.is_empty())
}
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)?;
let guard_path = self.large_integer_guard_path(sub_id, &filter)?;
if guard_path.is_empty() {
return self.json_del(&key, &filter).await;
}
let reply: redis::Value = redis::Script::new(REMOVE_INTEGER_ID)
.key(&key)
.arg(&filter)
.arg(&guard_path)
.invoke_async(&mut self.client.conn())
.await?;
Ok(check_array_count_reply(reply, None)? as u64)
}
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 {
let mut rows: Vec<T> = decode_array_chunk(Some(chunk))?;
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 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 as u64);
}
let chunk = self
.json_get_chunk(&self.meta.array_key_of(parts)?, &filter)
.await?;
Ok(decode_array_chunk::<serde_json::Value>(chunk.as_deref())?.len() as u64)
}
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 property = super::query::json_path_property(&self.meta.id_name)?;
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(),
));
}
if v == 0.0
&& sub_id
.split(['e', 'E'])
.next()
.unwrap_or_default()
.bytes()
.any(|byte| matches!(byte, b'1'..=b'9'))
{
return Err(NasaRedisError::Config(
"ARRAY 非零数值 ID 不能下溢为零".into(),
));
}
if v.abs() >= 9_007_199_254_740_992.0 {
return Err(NasaRedisError::Config(
"ARRAY 数值 ID 超出浮点比较范围;大整数必须使用 i64 整数文本或字符串身份"
.into(),
));
}
format!("{v}")
}
} else {
super::query::json_path_literal(sub_id)?
};
Ok(format!("$[?(@{}=={})]", property, lit))
}
fn large_integer_guard_path(&self, sub_id: &str, filter: &str) -> Result<String> {
if self.meta.id_numeric
&& sub_id
.parse::<i64>()
.is_ok_and(|value| value.unsigned_abs() >= 9_007_199_254_740_992)
{
Ok(format!(
"{}{}",
filter,
super::query::json_path_property(&self.meta.id_name)?
))
} else {
Ok(String::new())
}
}
async fn json_get_identity_chunk(
&self,
key: &str,
sub_id: &str,
filter: &str,
) -> Result<Option<String>> {
let guard_path = self.large_integer_guard_path(sub_id, filter)?;
if guard_path.is_empty() {
return self.json_get_chunk(key, filter).await;
}
let raw: redis::Value = redis::Script::new(READ_INTEGER_ID)
.key(key)
.arg(filter)
.arg(&guard_path)
.invoke_async(&mut self.client.conn())
.await?;
match raw {
redis::Value::Nil => Ok(None),
redis::Value::BulkString(bytes) => String::from_utf8(bytes)
.map(Some)
.map_err(|_| NasaRedisError::Codec("ARRAY JSON 回复不是有效 UTF-8".into())),
_ => Err(NasaRedisError::Codec(
"ARRAY 身份读取回复类型不符合约束".into(),
)),
}
}
async fn json_get_chunk(&self, key: &str, filter: &str) -> Result<Option<String>> {
let raw: redis::Value = redis::cmd("JSON.GET")
.arg(key)
.arg(filter)
.query_async(&mut self.client.conn())
.await?;
match raw {
redis::Value::Nil => Ok(None),
redis::Value::BulkString(bytes) => String::from_utf8(bytes)
.map(Some)
.map_err(|_| NasaRedisError::Codec("ARRAY JSON 回复不是有效 UTF-8".into())),
_ => Err(NasaRedisError::Codec(
"ARRAY JSON.GET 回复类型不符合约束".into(),
)),
}
}
async fn json_get_entities(&self, key: &str, filter: &str) -> Result<Vec<T>> {
let chunk = self.json_get_chunk(key, filter).await?;
decode_array_chunk(chunk.as_deref())
}
async fn json_del(&self, key: &str, filter: &str) -> Result<u64> {
let reply: redis::Value = redis::cmd("JSON.DEL")
.arg(key)
.arg(filter)
.query_async(&mut self.client.conn())
.await?;
Ok(check_array_count_reply(reply, None)? 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 reply: redis::Value = inv.invoke_async(&mut self.client.conn()).await?;
let redis::Value::Array(chunks) = reply else {
return Err(NasaRedisError::Codec("ARRAY 多桶读取回复不是数组".into()));
};
if chunks.len() > keys.len() {
return Err(NasaRedisError::Codec(
"ARRAY 多桶读取片段数超过请求桶数".into(),
));
}
chunks
.into_iter()
.map(|chunk| match chunk {
redis::Value::BulkString(bytes) => String::from_utf8(bytes)
.map_err(|_| NasaRedisError::Codec("ARRAY JSON 回复不是有效 UTF-8".into())),
_ => Err(NasaRedisError::Codec(
"ARRAY 多桶读取片段不是 BulkString".into(),
)),
})
.collect()
}
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 reply: redis::Value = inv.invoke_async(&mut self.client.conn()).await?;
check_array_count_reply(reply, None)
}
}
fn check_array_count_reply(reply: redis::Value, expected: Option<usize>) -> Result<i64> {
let count = match reply {
redis::Value::Int(count) if count >= 0 => count,
_ => return Err(NasaRedisError::Codec("ARRAY 命令未返回非负整数计数".into())),
};
if expected.is_some_and(|expected| usize::try_from(count).ok() != Some(expected)) {
return Err(NasaRedisError::Codec("ARRAY 写入确认数量不符合请求".into()));
}
Ok(count)
}
fn decode_array_chunk<T: DeserializeOwned>(chunk: Option<&str>) -> Result<Vec<T>> {
match chunk {
None => Ok(Vec::new()),
Some(chunk) => serde_json::from_str(chunk).map_err(|error| {
NasaRedisError::Codec(format!(
"ARRAY JSON 解码失败: {:?} at {}:{}",
error.classify(),
error.line(),
error.column()
))
}),
}
}
fn encode_array_document<T: Serialize>(doc: &T, meta: &DocMeta, id: &str) -> Result<String> {
let value = super::to_json_value_omit_null(doc)?;
let stored = value.get(&meta.id_name);
let matches = if meta.id_numeric {
let number = stored.and_then(serde_json::Value::as_number);
match (
id.parse::<i64>(),
number.and_then(serde_json::Number::as_i64),
) {
(Ok(expected), Some(actual)) => expected == actual,
_ => {
match (
id.parse::<f64>(),
number.and_then(serde_json::Number::as_f64),
) {
(Ok(expected), Some(actual)) => {
expected.abs() < 9_007_199_254_740_992.0
&& actual.abs() < 9_007_199_254_740_992.0
&& expected == actual
}
_ => false,
}
}
}
} else {
stored.and_then(serde_json::Value::as_str) == Some(id)
};
if !matches {
return Err(NasaRedisError::Config(
"ARRAY 文档编码的身份与 ID 不一致".into(),
));
}
serde_json::to_string(&value).map_err(|error| {
NasaRedisError::Codec(format!(
"JSON 文档编码失败: {:?} at {}:{}",
error.classify(),
error.line(),
error.column()
))
})
}