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};
const HASH_SAVE_LUA: &str = r#"
local n = tonumber(ARGV[1])
local keep = {}
for i = 0, n - 1 do keep[ARGV[2 + i * 2]] = true end
local existing = redis.call('HKEYS', KEYS[1])
for _, k in ipairs(existing) do
if not keep[k] then redis.call('HDEL', KEYS[1], k) end
end
if n > 0 then
local args = {}
for i = 2, #ARGV do args[#args + 1] = ARGV[i] end
redis.call('HSET', KEYS[1], unpack(args))
end
return 1
"#;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum IndexPolicy {
ValidateOnly,
CreateIfMissing,
RecreateExplicitly,
}
pub struct SearchActuator<T: RedisDocument> {
client: Arc<RedisClient>,
meta: &'static DocMeta,
_t: PhantomData<T>,
}
impl<T: RedisDocument> SearchActuator<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 而非 SearchActuator",
meta.index, meta.data_type
)));
}
let ft: std::result::Result<redis::Value, _> =
redis::cmd("FT._LIST").query_async(&mut client.conn()).await;
if let Err(e) = ft {
return Err(NasaRedisError::Config(format!(
"RediSearch 模块不可用(需 Redis Stack):{e}"
)));
}
if matches!(meta.data_type, DataType::Json) {
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 模块不可用(JSON DataType 需要):{e}"
)));
}
return Err(e.into());
}
}
Ok(Self {
client,
meta,
_t: PhantomData,
})
}
pub fn meta(&self) -> &'static DocMeta {
self.meta
}
pub async fn ensure_index(&self, policy: IndexPolicy) -> Result<()> {
let exists = self.index_exists().await?;
match (policy, exists) {
(IndexPolicy::ValidateOnly, false) => Err(NasaRedisError::Config(format!(
"索引 {} 不存在(ValidateOnly)",
self.meta.index
))),
(IndexPolicy::ValidateOnly, true) | (IndexPolicy::CreateIfMissing, true) => {
self.validate_schema().await
}
(IndexPolicy::CreateIfMissing, false) => self.create_index().await,
(IndexPolicy::RecreateExplicitly, existed) => {
if existed {
let _: String = redis::cmd("FT.DROPINDEX")
.arg(&self.meta.index)
.query_async(&mut self.client.conn())
.await?;
tracing::warn!(index = %self.meta.index, "索引已显式 DROP(文档保留),即将重建");
}
self.create_index().await
}
}
}
pub async fn index_exists(&self) -> Result<bool> {
let r: std::result::Result<redis::Value, redis::RedisError> = redis::cmd("FT.INFO")
.arg(&self.meta.index)
.query_async(&mut self.client.conn())
.await;
match r {
Ok(_) => Ok(true),
Err(e) => {
if is_unknown_index_error(&e) {
Ok(false)
} else {
Err(e.into())
}
}
}
}
async fn create_index(&self) -> Result<()> {
let mut cmd = redis::cmd("FT.CREATE");
cmd.arg(&self.meta.index)
.arg("ON")
.arg(match self.meta.data_type {
DataType::Hash => "HASH",
_ => "JSON",
})
.arg("PREFIX")
.arg(1)
.arg(self.meta.literal_prefix())
.arg("SCHEMA");
for a in self.meta.schema_args() {
cmd.arg(a);
}
let _: String = cmd.query_async(&mut self.client.conn()).await?;
tracing::info!(index = %self.meta.index, "索引已创建");
Ok(())
}
async fn validate_schema(&self) -> Result<()> {
let info: redis::Value = redis::cmd("FT.INFO")
.arg(&self.meta.index)
.query_async(&mut self.client.conn())
.await?;
let prof = normalize_index(&info);
let idx = &self.meta.index;
let drift = |m: String| {
NasaRedisError::Config(format!(
"索引 {idx} schema 漂移:{m}(禁自动 DROP,需 RecreateExplicitly)"
))
};
let want_kt = if matches!(self.meta.data_type, DataType::Hash) {
"HASH"
} else {
"JSON"
};
if !prof.key_type.is_empty() && !prof.key_type.eq_ignore_ascii_case(want_kt) {
return Err(drift(format!(
"ON 类型期望 {want_kt} 实际 {}",
prof.key_type
)));
}
let want_prefix = self.meta.literal_prefix();
if !prof.prefixes.is_empty() && !prof.prefixes.iter().any(|p| p == want_prefix) {
return Err(drift(format!(
"PREFIX 期望含 \"{want_prefix}\" 实际 {:?}",
prof.prefixes
)));
}
for f in &self.meta.fields {
let alias = f.alias_or_name();
let want_ty = match f.ftype {
super::FieldType::Tag {
..
} => "TAG",
super::FieldType::Text {
..
} => "TEXT",
super::FieldType::Numeric {
..
} => "NUMERIC",
super::FieldType::Geo => "GEO",
};
let Some(ai) = prof.attrs.get(alias) else {
return Err(drift(format!(
"缺字段 \"{alias}\"(实际有 {:?})",
prof.attrs.keys().collect::<Vec<_>>()
)));
};
if !ai.ftype.eq_ignore_ascii_case(want_ty) {
return Err(drift(format!(
"字段 \"{alias}\" 类型期望 {want_ty} 实际 {}",
ai.ftype
)));
}
let want_sortable = match f.ftype {
super::FieldType::Tag {
sortable,
..
}
| super::FieldType::Text {
sortable,
..
}
| super::FieldType::Numeric {
sortable,
..
} => sortable,
super::FieldType::Geo => continue,
};
if want_sortable != ai.sortable {
return Err(drift(format!(
"字段 \"{alias}\" SORTABLE 期望 {want_sortable} 实际 {}",
ai.sortable
)));
}
if let super::FieldType::Tag {
separator,
case_sensitive,
..
} = &f.ftype
{
if let (Some(want), Some(got)) = (separator, &ai.separator) {
if want.to_string() != *got {
return Err(drift(format!(
"字段 \"{alias}\" SEPARATOR 期望 {want:?} 实际 {got:?}"
)));
}
}
if *case_sensitive != ai.case_sensitive {
return Err(drift(format!(
"字段 \"{alias}\" CASESENSITIVE 期望 {case_sensitive} 实际 {}",
ai.case_sensitive
)));
}
}
if let super::FieldType::Text {
weight,
no_stem,
no_index,
..
} = &f.ftype
{
if let Some(got) = ai.weight {
if (got - *weight).abs() > 1e-6 {
return Err(drift(format!(
"字段 \"{alias}\" WEIGHT 期望 {weight} 实际 {got}"
)));
}
}
if *no_stem != ai.no_stem {
return Err(drift(format!(
"字段 \"{alias}\" NOSTEM 期望 {no_stem} 实际 {}",
ai.no_stem
)));
}
if *no_index != ai.no_index {
return Err(drift(format!(
"字段 \"{alias}\" NOINDEX 期望 {no_index} 实际 {}",
ai.no_index
)));
}
}
if let super::FieldType::Numeric {
no_index,
..
} = &f.ftype
{
if *no_index != ai.no_index {
return Err(drift(format!(
"字段 \"{alias}\" NOINDEX 期望 {no_index} 实际 {}",
ai.no_index
)));
}
}
}
Ok(())
}
fn key_for(&self, doc: &T) -> Result<String> {
if self.meta.has_placeholder() {
let parts = doc.placeholder_parts();
let refs: Vec<&str> = parts.iter().map(|s| s.as_str()).collect();
self.meta.key_of_parts(&refs, &doc.id())
} else {
self.meta.key_of(&doc.id())
}
}
pub async fn save(&self, doc: &T) -> Result<()>
where
T: Serialize,
{
let key = self.key_for(doc)?;
self.save_at(&key, doc).await
}
fn build_save_cmd(&self, key: &str, doc: &T) -> Result<redis::Cmd>
where
T: Serialize,
{
match self.meta.data_type {
DataType::Hash => {
let fields = doc.to_fields();
let mut cmd = redis::cmd("EVAL");
cmd.arg(HASH_SAVE_LUA).arg(1).arg(key).arg(fields.len());
for (f, v) in &fields {
cmd.arg(f).arg(v);
}
Ok(cmd)
}
_ => {
let body = super::to_json_omit_null(doc)?;
let mut cmd = redis::cmd("JSON.SET");
cmd.arg(key).arg("$").arg(&body);
Ok(cmd)
}
}
}
async fn save_at(&self, key: &str, doc: &T) -> Result<()>
where
T: Serialize,
{
let cmd = self.build_save_cmd(key, doc)?;
let _: redis::Value = cmd.query_async(&mut self.client.conn()).await?;
Ok(())
}
pub async fn save_all(&self, docs: &[T]) -> Result<usize>
where
T: Serialize,
{
if docs.is_empty() {
return Ok(0);
}
let chunk_sz = self.client.config().pipeline.session_max_commands.max(1);
for chunk in docs.chunks(chunk_sz) {
let mut sess = self.client.pipeline();
let mut tickets = Vec::with_capacity(chunk.len());
for doc in chunk {
let key = self.key_for(doc)?;
let cmd = self.build_save_cmd(&key, doc)?;
tickets.push(sess.enqueue::<redis::Value>(cmd)?);
}
sess.execute().await?;
for t in tickets {
t.await_result()?;
}
}
Ok(docs.len())
}
pub async fn find_by_id(&self, id: &str) -> Result<Option<T>>
where
T: DeserializeOwned,
{
let key = self.meta.key_of(id)?;
self.find_at(&key).await
}
pub async fn find_by_parts(&self, parts: &[&str], id: &str) -> Result<Option<T>>
where
T: DeserializeOwned,
{
let key = self.meta.key_of_parts(parts, id)?;
self.find_at(&key).await
}
async fn find_at(&self, key: &str) -> Result<Option<T>>
where
T: DeserializeOwned,
{
match self.meta.data_type {
DataType::Hash => {
let fields: HashMap<String, String> = self.client.h_get_all(key).await?;
if fields.is_empty() {
return Ok(None);
}
Ok(Some(T::from_fields(&fields)?))
}
_ => {
let raw: Option<String> = redis::cmd("JSON.GET")
.arg(key)
.arg("$")
.query_async(&mut self.client.conn())
.await?;
match raw {
None => Ok(None),
Some(s) => {
let mut v: Vec<T> = serde_json::from_str(&s)
.map_err(|e| NasaRedisError::Codec(format!("JSON 解码失败: {e}")))?;
Ok(v.pop())
}
}
}
}
}
pub async fn remove_by_id(&self, id: &str) -> Result<bool> {
Ok(self.client.del(&[&self.meta.key_of(id)?]).await? > 0)
}
pub async fn remove_by_parts(&self, parts: &[&str], id: &str) -> Result<bool> {
Ok(self
.client
.del(&[&self.meta.key_of_parts(parts, id)?])
.await?
> 0)
}
pub async fn drop_index(&self, delete_documents: bool) -> Result<()> {
let mut cmd = redis::cmd("FT.DROPINDEX");
cmd.arg(&self.meta.index);
if delete_documents {
cmd.arg("DD");
}
match cmd.query_async::<()>(&mut self.client.conn()).await {
Ok(()) => Ok(()),
Err(e) if is_unknown_index_error(&e) => Ok(()),
Err(e) => Err(e.into()),
}
}
pub async fn exists_by_id(&self, id: &str) -> Result<bool> {
let key = self.meta.key_of(id)?;
self.client.exists(&key).await
}
pub async fn exists_by_parts(&self, parts: &[&str], id: &str) -> Result<bool> {
let key = self.meta.key_of_parts(parts, id)?;
self.client.exists(&key).await
}
pub async fn json_num_incr_by(&self, id: &str, json_path: &str, delta: i64) -> Result<String> {
self.json_num_incr_by_at(&self.meta.key_of(id)?, json_path, delta)
.await
}
pub async fn json_num_incr_by_parts(
&self,
parts: &[&str],
id: &str,
json_path: &str,
delta: i64,
) -> Result<String> {
self.json_num_incr_by_at(&self.meta.key_of_parts(parts, id)?, json_path, delta)
.await
}
async fn json_num_incr_by_at(&self, key: &str, json_path: &str, delta: i64) -> Result<String> {
if self.meta.data_type == DataType::Hash {
return Err(NasaRedisError::Config(
"json_num_incr_by 仅 JSON 模式可用(当前 Hash 模式)".into(),
));
}
let s: String = redis::cmd("JSON.NUMINCRBY")
.arg(key)
.arg(json_path)
.arg(delta)
.query_async(&mut self.client.conn())
.await?;
Ok(s)
}
pub async fn find_one(&self, q: &Query) -> Result<Option<T>>
where
T: DeserializeOwned,
{
let one = q.clone().limit(0, 1);
Ok(self.find(&one).await?.into_iter().next())
}
pub async fn exists(&self, q: &Query) -> Result<bool> {
Ok(self.count(q).await? > 0)
}
pub async fn find_keys(&self, q: &Query) -> Result<Vec<String>> {
let (offset, limit) = if q.is_limit_explicit() {
(q.effective_offset(), q.effective_limit())
} else {
(0, 1_000_000)
};
self.search_keys(q, offset, limit).await
}
async fn search_keys(&self, q: &Query, offset: usize, limit: usize) -> Result<Vec<String>> {
if self.meta.has_placeholder() {
return Err(NasaRedisError::Config(
"find_keys/remove(query) 不支持占位符 prefix 模式(key 无法反推 id)".into(),
));
}
let expr = q.render(self.meta)?;
if expr.is_empty() {
return Ok(Vec::new()); }
let q_for_keys = q.clone().limit(offset, limit);
let mut cmd = redis::cmd("FT.SEARCH");
cmd.arg(&self.meta.index).arg(&expr).arg("NOCONTENT");
for a in q_for_keys.render_args(self.meta)? {
cmd.arg(a);
}
cmd.arg("DIALECT").arg(2);
let v: redis::Value = cmd.query_async(&mut self.client.conn()).await?;
let prefix = self.meta.literal_prefix();
Ok(parse_search_keys(v)
.into_iter()
.map(|k| k.strip_prefix(prefix).unwrap_or(&k).to_string())
.collect())
}
pub async fn remove(&self, q: &Query) -> Result<u64> {
let prefix = self.meta.literal_prefix();
let mut total = 0u64;
loop {
let ids = self.search_keys(q, 0, 1_000_000).await?;
if ids.is_empty() {
break;
}
let mut deleted = 0u64;
for chunk in ids.chunks(1000) {
let keys: Vec<String> = chunk.iter().map(|id| format!("{prefix}{id}")).collect();
let krefs: Vec<&str> = keys.iter().map(|s| s.as_str()).collect();
deleted += self.client.del(&krefs).await?;
}
total += deleted;
if deleted == 0 {
break; }
}
Ok(total)
}
pub async fn find(&self, q: &Query) -> Result<Vec<T>>
where
T: DeserializeOwned,
{
let expr = q.render(self.meta)?;
if expr.is_empty() {
return Ok(Vec::new()); }
let mut cmd = redis::cmd("FT.SEARCH");
cmd.arg(&self.meta.index).arg(&expr);
for a in q.render_args(self.meta)? {
cmd.arg(a);
}
cmd.arg("DIALECT").arg(2); let v: redis::Value = cmd.query_async(&mut self.client.conn()).await?;
self.parse_search(v)
}
pub async fn count(&self, q: &Query) -> Result<u64> {
let expr = q.render(self.meta)?;
if expr.is_empty() {
return Ok(0); }
let v: redis::Value = redis::cmd("FT.SEARCH")
.arg(&self.meta.index)
.arg(&expr)
.arg("LIMIT")
.arg(0)
.arg(0)
.arg("DIALECT")
.arg(2) .query_async(&mut self.client.conn())
.await?;
if let redis::Value::Array(parts) | redis::Value::Set(parts) = &v {
if let Some(n) = parts.first().and_then(value_to_u64) {
return Ok(n);
}
}
if let redis::Value::Map(pairs) = &v {
if let Some(n) = resp3_map_get(pairs, "total_results").and_then(value_to_u64) {
return Ok(n);
}
}
Err(NasaRedisError::Config("FT.SEARCH 计数响应形态异常".into()))
}
pub async fn aggregate(
&self,
q: &Query,
agg: &super::query::Aggregate,
) -> Result<Vec<HashMap<String, String>>> {
let expr = q.render(self.meta)?;
if expr.is_empty() {
return Ok(Vec::new()); }
let mut cmd = redis::cmd("FT.AGGREGATE");
cmd.arg(&self.meta.index).arg(&expr);
for a in agg.render_args(self.meta)? {
cmd.arg(a);
}
cmd.arg("DIALECT").arg(2); let v: redis::Value = cmd.query_async(&mut self.client.conn()).await?;
if let redis::Value::Map(pairs) = &v {
let mut out = Vec::new();
if let Some(redis::Value::Array(rows)) = resp3_map_get(pairs, "results") {
for row in rows {
out.push(resp3_row_fields(row));
}
}
return Ok(out);
}
let redis::Value::Array(parts) = v else {
return Err(NasaRedisError::Config(
"FT.AGGREGATE 响应形态异常(非 RESP2 数组/RESP3 Map)".into(),
));
};
let mut out = Vec::new();
let mut it = parts.into_iter();
let _total = it.next(); for row in it {
let redis::Value::Array(kv) = row else {
continue;
};
let mut map = HashMap::new();
let mut kit = kv.into_iter();
while let (Some(k), Some(val)) = (kit.next(), kit.next()) {
map.insert(bulk_to_string(k), bulk_to_string(val));
}
out.push(map);
}
Ok(out)
}
fn map_to_item(&self, map: HashMap<String, String>) -> Result<T>
where
T: DeserializeOwned,
{
match self.meta.data_type {
DataType::Hash => T::from_fields(&map),
_ => {
let raw = map
.get("$")
.or_else(|| map.values().next())
.ok_or_else(|| {
NasaRedisError::Config("FT.SEARCH(JSON)无任何字段可解".into())
})?;
serde_json::from_str(raw)
.map_err(|e| NasaRedisError::Codec(format!("JSON 解码失败: {e}")))
}
}
}
fn parse_search(&self, v: redis::Value) -> Result<Vec<T>>
where
T: DeserializeOwned,
{
if let redis::Value::Map(pairs) = &v {
let mut out = Vec::new();
if let Some(redis::Value::Array(rows)) = resp3_map_get(pairs, "results") {
for row in rows {
out.push(self.map_to_item(resp3_row_fields(row))?);
}
}
return Ok(out);
}
let redis::Value::Array(parts) = v else {
return Err(NasaRedisError::Config(
"FT.SEARCH 响应形态异常(非 RESP2 数组/RESP3 Map)".into(),
));
};
let mut out = Vec::new();
let mut it = parts.into_iter();
let _total = it.next(); while let Some(_key) = it.next() {
let Some(redis::Value::Array(fields)) = it.next() else {
break;
};
let mut map: HashMap<String, String> = HashMap::new();
let mut fit = fields.into_iter();
while let (Some(f), Some(val)) = (fit.next(), fit.next()) {
let fname = bulk_to_string(f);
let fval = bulk_to_string(val);
map.insert(fname, fval);
}
out.push(self.map_to_item(map)?);
}
Ok(out)
}
}
fn is_unknown_index_error(e: &redis::RedisError) -> bool {
let msg = e.to_string().to_lowercase();
msg.contains("unknown index name") || msg.contains("no such index")
}
fn bulk_to_string(v: redis::Value) -> String {
match v {
redis::Value::BulkString(b) => String::from_utf8_lossy(&b).into_owned(),
redis::Value::SimpleString(s) => s,
ref other => value_to_string(other),
}
}
fn parse_search_keys(v: redis::Value) -> Vec<String> {
if let redis::Value::Map(pairs) = &v {
let mut out = Vec::new();
if let Some(redis::Value::Array(rows)) = resp3_map_get(pairs, "results") {
for row in rows {
if let redis::Value::Map(rp) = row {
if let Some(idv) = resp3_map_get(rp, "id") {
out.push(value_to_string(idv));
}
}
}
}
return out;
}
if let redis::Value::Array(parts) = v {
let mut it = parts.into_iter();
let _total = it.next(); return it.map(bulk_to_string).collect();
}
Vec::new()
}
fn value_to_u64(v: &redis::Value) -> Option<u64> {
match v {
redis::Value::Int(n) => (*n >= 0).then_some(*n as u64),
redis::Value::Double(d) => (*d >= 0.0).then_some(*d as u64),
redis::Value::BulkString(b) => String::from_utf8_lossy(b).trim().parse::<u64>().ok(),
redis::Value::SimpleString(s) => s.trim().parse::<u64>().ok(),
_ => None,
}
}
fn value_to_string(v: &redis::Value) -> String {
match v {
redis::Value::BulkString(b) => String::from_utf8_lossy(b).into_owned(),
redis::Value::SimpleString(s) => s.clone(),
redis::Value::Int(n) => n.to_string(),
redis::Value::Double(d) => d.to_string(),
other => format!("{other:?}"),
}
}
fn resp3_map_get<'a>(
pairs: &'a [(redis::Value, redis::Value)],
key: &str,
) -> Option<&'a redis::Value> {
pairs
.iter()
.find_map(|(k, v)| (val_str(k).as_deref() == Some(key)).then_some(v))
}
fn resp3_row_fields(row: &redis::Value) -> HashMap<String, String> {
let mut map = HashMap::new();
if let redis::Value::Map(pairs) = row {
let fields =
resp3_map_get(pairs, "extra_attributes").or_else(|| resp3_map_get(pairs, "attributes"));
if let Some(redis::Value::Map(fields)) = fields {
for (f, v) in fields {
map.insert(value_to_string(f), value_to_string(v));
}
}
}
map
}
fn val_str(v: &redis::Value) -> Option<String> {
match v {
redis::Value::SimpleString(s) => Some(s.clone()),
redis::Value::BulkString(b) => Some(String::from_utf8_lossy(b).into_owned()),
_ => None,
}
}
fn val_f64(v: &redis::Value) -> Option<f64> {
match v {
redis::Value::Double(d) => Some(*d),
redis::Value::Int(i) => Some(*i as f64),
_ => val_str(v).and_then(|s| s.parse().ok()),
}
}
fn info_pairs(v: &redis::Value) -> Vec<(&redis::Value, &redis::Value)> {
match v {
redis::Value::Map(m) => m.iter().map(|(k, v)| (k, v)).collect(),
redis::Value::Array(a) => a
.as_chunks::<2>()
.0
.iter()
.map(|c| (&c[0], &c[1]))
.collect(),
_ => Vec::new(),
}
}
pub fn normalize_attributes(info: &redis::Value) -> HashMap<String, String> {
let mut out = HashMap::new();
for (k, v) in info_pairs(info) {
if !matches!(val_str(k).as_deref(), Some("attributes") | Some("fields")) {
continue;
}
let redis::Value::Array(attrs) = v else {
continue;
};
for attr in attrs {
if let Some((alias, ai)) = parse_attr_value(attr) {
out.insert(alias, ai.ftype);
}
}
}
out
}
#[derive(Debug, Default, Clone)]
pub struct AttrInfo {
pub ftype: String,
pub sortable: bool,
pub no_stem: bool,
pub no_index: bool,
pub case_sensitive: bool,
pub weight: Option<f64>,
pub separator: Option<String>,
}
#[derive(Debug, Default)]
pub struct IndexProfile {
pub key_type: String,
pub prefixes: Vec<String>,
pub attrs: HashMap<String, AttrInfo>,
}
fn apply_flag(info: &mut AttrInfo, flag: &str) {
match flag.to_ascii_uppercase().as_str() {
"SORTABLE" => info.sortable = true,
"NOSTEM" => info.no_stem = true,
"NOINDEX" => info.no_index = true,
"CASESENSITIVE" => info.case_sensitive = true,
_ => {}
}
}
fn parse_attr_value(attr: &redis::Value) -> Option<(String, AttrInfo)> {
match attr {
redis::Value::Map(_) => {
let mut alias: Option<String> = None;
let mut identifier: Option<String> = None;
let mut info = AttrInfo::default();
for (k, v) in info_pairs(attr) {
match val_str(k)
.as_deref()
.map(|s| s.to_ascii_uppercase())
.as_deref()
{
Some("ATTRIBUTE") | Some("ALIAS") => alias = val_str(v),
Some("IDENTIFIER") => identifier = val_str(v),
Some("TYPE") => info.ftype = val_str(v).unwrap_or_default(),
Some("WEIGHT") => info.weight = val_f64(v),
Some("SEPARATOR") => info.separator = val_str(v),
Some("FLAGS") => {
if let redis::Value::Array(flags) = v {
for f in flags {
if let Some(s) = val_str(f) {
apply_flag(&mut info, &s);
}
}
}
}
_ => {}
}
}
let key = alias.or(identifier)?;
Some((key, info))
}
redis::Value::Array(kv) => {
let mut alias: Option<String> = None;
let mut identifier: Option<String> = None;
let mut info = AttrInfo::default();
let mut i = 0;
while i < kv.len() {
let Some(tok) = val_str(&kv[i]) else {
i += 1;
continue;
};
match tok.to_ascii_uppercase().as_str() {
"ATTRIBUTE" | "ALIAS" => {
alias = kv.get(i + 1).and_then(val_str);
i += 2;
}
"IDENTIFIER" => {
identifier = kv.get(i + 1).and_then(val_str);
i += 2;
}
"TYPE" => {
info.ftype = kv.get(i + 1).and_then(val_str).unwrap_or_default();
i += 2;
}
"WEIGHT" => {
info.weight = kv.get(i + 1).and_then(val_f64);
i += 2;
}
"SEPARATOR" => {
info.separator = kv.get(i + 1).and_then(val_str);
i += 2;
}
"PHONETIC" => i += 2, "SORTABLE" | "NOSTEM" | "NOINDEX" | "CASESENSITIVE" => {
apply_flag(&mut info, &tok);
i += 1;
}
_ => i += 1, }
}
let key = alias.or(identifier)?;
Some((key, info))
}
_ => None,
}
}
pub fn normalize_index(info: &redis::Value) -> IndexProfile {
let mut prof = IndexProfile::default();
for (k, v) in info_pairs(info) {
match val_str(k).as_deref() {
Some("index_definition") => {
for (dk, dv) in info_pairs(v) {
match val_str(dk).as_deref() {
Some("key_type") => prof.key_type = val_str(dv).unwrap_or_default(),
Some("prefixes") => {
if let redis::Value::Array(ps) = dv {
prof.prefixes = ps.iter().filter_map(val_str).collect();
}
}
_ => {}
}
}
}
Some("attributes") | Some("fields") => {
if let redis::Value::Array(attrs) = v {
for attr in attrs {
if let Some((alias, ai)) = parse_attr_value(attr) {
prof.attrs.insert(alias, ai);
}
}
}
}
_ => {}
}
}
prof
}