#![allow(deprecated)]
use redis_tower_commands::{FtSearch, SortOrder};
use redis_tower_core::{Frame, RedisError};
use serde::de::DeserializeOwned;
use crate::RedisExecutor;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SortDir {
Asc,
Desc,
}
#[derive(Debug)]
pub struct SearchResults<T> {
pub total: i64,
pub docs: Vec<SearchDoc<T>>,
}
#[derive(Debug)]
pub struct SearchDoc<T> {
pub key: String,
pub doc: T,
pub score: Option<f64>,
}
#[deprecated(
since = "0.2.0",
note = "Use `redis_tower_modules::search::SearchClient` instead. This type will be removed in a future release."
)]
pub struct Search {
index: String,
query: String,
filters: Vec<String>,
sort_field: Option<String>,
sort_dir: Option<SortDir>,
return_fields: Vec<String>,
offset: Option<u64>,
count: Option<u64>,
nocontent: bool,
verbatim: bool,
withscores: bool,
}
impl Search {
pub fn new(index: impl Into<String>, query: impl Into<String>) -> Self {
Self {
index: index.into(),
query: query.into(),
filters: Vec::new(),
sort_field: None,
sort_dir: None,
return_fields: Vec::new(),
offset: None,
count: None,
nocontent: false,
verbatim: false,
withscores: false,
}
}
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filters.push(filter.into());
self
}
pub fn sort_by(mut self, field: impl Into<String>, dir: SortDir) -> Self {
self.sort_field = Some(field.into());
self.sort_dir = Some(dir);
self
}
pub fn return_fields(mut self, fields: &[&str]) -> Self {
self.return_fields = fields.iter().map(|f| (*f).to_string()).collect();
self
}
pub fn limit(mut self, offset: u64, count: u64) -> Self {
self.offset = Some(offset);
self.count = Some(count);
self
}
pub fn nocontent(mut self) -> Self {
self.nocontent = true;
self
}
pub fn verbatim(mut self) -> Self {
self.verbatim = true;
self
}
pub fn withscores(mut self) -> Self {
self.withscores = true;
self
}
fn effective_query(&self) -> String {
if self.filters.is_empty() {
return self.query.clone();
}
let mut q = self.query.clone();
for filter in &self.filters {
q.push(' ');
q.push_str(filter);
}
q
}
fn to_ft_search(&self) -> FtSearch {
let query = self.effective_query();
let mut cmd = FtSearch::new(&self.index, &query);
if let Some(offset) = self.offset {
cmd = cmd.limit(offset, self.count.unwrap_or(10));
}
if !self.return_fields.is_empty() {
let field_refs: Vec<&str> = self.return_fields.iter().map(String::as_str).collect();
cmd = cmd.return_fields(&field_refs);
}
if let Some(field) = &self.sort_field {
let order = match self.sort_dir.unwrap_or(SortDir::Asc) {
SortDir::Asc => SortOrder::Asc,
SortDir::Desc => SortOrder::Desc,
};
cmd = cmd.sortby(field, order);
}
if self.nocontent {
cmd = cmd.nocontent();
}
if self.verbatim {
cmd = cmd.verbatim();
}
if self.withscores {
cmd = cmd.withscores();
}
cmd
}
pub async fn search<T: DeserializeOwned>(
self,
conn: &mut impl RedisExecutor,
) -> Result<SearchResults<T>, RedisError> {
let withscores = self.withscores;
let cmd = self.to_ft_search();
let frame = conn.execute(cmd).await?;
parse_search_results(frame, withscores)
}
}
fn extract_string(frame: &Frame) -> Result<String, RedisError> {
match frame {
Frame::BulkString(Some(data)) => {
String::from_utf8(data.to_vec()).map_err(|e| RedisError::Redis(format!("{e}")))
}
_ => Err(RedisError::UnexpectedResponse {
expected: "bulk string",
actual: format!("{frame:?}"),
}),
}
}
fn parse_search_results<T: DeserializeOwned>(
frame: Frame,
withscores: bool,
) -> Result<SearchResults<T>, RedisError> {
let items = match frame {
Frame::Array(Some(items)) => items,
_ => {
return Err(RedisError::UnexpectedResponse {
expected: "array",
actual: format!("{frame:?}"),
});
}
};
if items.is_empty() {
return Err(RedisError::UnexpectedResponse {
expected: "non-empty array with total count",
actual: "empty array".to_string(),
});
}
let total = match &items[0] {
Frame::Integer(n) => *n,
_ => {
return Err(RedisError::UnexpectedResponse {
expected: "integer (total count)",
actual: format!("{:?}", items[0]),
});
}
};
let mut docs = Vec::new();
let mut i = 1;
while i < items.len() {
let key = extract_string(&items[i])?;
i += 1;
let score = if withscores {
if i >= items.len() {
return Err(RedisError::UnexpectedResponse {
expected: "score value",
actual: "end of array".to_string(),
});
}
let s = extract_string(&items[i])?;
i += 1;
Some(s.parse::<f64>().unwrap_or(0.0))
} else {
None
};
if i >= items.len() {
return Err(RedisError::UnexpectedResponse {
expected: "field/value array",
actual: "end of array".to_string(),
});
}
let fields = match &items[i] {
Frame::Array(Some(fields)) => fields,
_ => {
return Err(RedisError::UnexpectedResponse {
expected: "array of field/value pairs",
actual: format!("{:?}", items[i]),
});
}
};
i += 1;
let mut map = serde_json::Map::new();
for chunk in fields.chunks(2) {
if chunk.len() < 2 {
continue;
}
let k = extract_string(&chunk[0])?;
let v = extract_string(&chunk[1])?;
map.insert(k, serde_json::Value::String(v));
}
let doc: T = serde_json::from_value(serde_json::Value::Object(map))
.map_err(|e| RedisError::Redis(format!("deserialize error: {e}")))?;
docs.push(SearchDoc { key, doc, score });
}
Ok(SearchResults { total, docs })
}
#[cfg(test)]
mod tests {
use super::*;
use bytes::Bytes;
use redis_tower_core::{Command, Frame};
use serde::Deserialize;
#[derive(Debug, Deserialize, PartialEq)]
struct Product {
name: String,
price: String,
category: String,
}
fn bs(s: &str) -> Frame {
Frame::BulkString(Some(Bytes::from(s.to_string())))
}
#[test]
fn search_builds_basic_ft_search() {
let search = Search::new("idx", "*");
let cmd = search.to_ft_search();
let frame = cmd.to_frame();
let args = match frame {
Frame::Array(Some(items)) => items,
_ => panic!("expected array frame"),
};
assert_eq!(args.len(), 3);
assert_eq!(extract_string(&args[0]).unwrap(), "FT.SEARCH");
assert_eq!(extract_string(&args[1]).unwrap(), "idx");
assert_eq!(extract_string(&args[2]).unwrap(), "*");
}
#[test]
fn search_builds_with_all_options() {
let search = Search::new("products", "shoes")
.filter("@price:[0 100]")
.sort_by("price", SortDir::Asc)
.return_fields(&["name", "price"])
.limit(0, 5)
.verbatim()
.withscores();
let cmd = search.to_ft_search();
let frame = cmd.to_frame();
let args = match frame {
Frame::Array(Some(items)) => items,
_ => panic!("expected array frame"),
};
let strs: Vec<String> = args.iter().map(|f| extract_string(f).unwrap()).collect();
assert_eq!(strs[0], "FT.SEARCH");
assert_eq!(strs[1], "products");
assert_eq!(strs[2], "shoes @price:[0 100]");
assert!(strs.contains(&"VERBATIM".to_string()));
assert!(strs.contains(&"WITHSCORES".to_string()));
assert!(strs.contains(&"LIMIT".to_string()));
assert!(strs.contains(&"RETURN".to_string()));
assert!(strs.contains(&"SORTBY".to_string()));
}
#[test]
fn parse_basic_search_results() {
let frame = Frame::Array(Some(vec![
Frame::Integer(2),
bs("doc:1"),
Frame::Array(Some(vec![
bs("name"),
bs("Shoe A"),
bs("price"),
bs("50"),
bs("category"),
bs("footwear"),
])),
bs("doc:2"),
Frame::Array(Some(vec![
bs("name"),
bs("Shoe B"),
bs("price"),
bs("75"),
bs("category"),
bs("footwear"),
])),
]));
let results: SearchResults<Product> = parse_search_results(frame, false).unwrap();
assert_eq!(results.total, 2);
assert_eq!(results.docs.len(), 2);
assert_eq!(results.docs[0].key, "doc:1");
assert_eq!(
results.docs[0].doc,
Product {
name: "Shoe A".into(),
price: "50".into(),
category: "footwear".into(),
}
);
assert!(results.docs[0].score.is_none());
assert_eq!(results.docs[1].key, "doc:2");
assert_eq!(
results.docs[1].doc,
Product {
name: "Shoe B".into(),
price: "75".into(),
category: "footwear".into(),
}
);
}
#[test]
fn parse_empty_results() {
let frame = Frame::Array(Some(vec![Frame::Integer(0)]));
let results: SearchResults<Product> = parse_search_results(frame, false).unwrap();
assert_eq!(results.total, 0);
assert!(results.docs.is_empty());
}
#[test]
fn parse_withscores_results() {
let frame = Frame::Array(Some(vec![
Frame::Integer(1),
bs("doc:1"),
bs("0.95"),
Frame::Array(Some(vec![
bs("name"),
bs("Shoe A"),
bs("price"),
bs("50"),
bs("category"),
bs("footwear"),
])),
]));
let results: SearchResults<Product> = parse_search_results(frame, true).unwrap();
assert_eq!(results.total, 1);
assert_eq!(results.docs.len(), 1);
assert_eq!(results.docs[0].key, "doc:1");
assert!((results.docs[0].score.unwrap() - 0.95).abs() < f64::EPSILON);
assert_eq!(results.docs[0].doc.name, "Shoe A");
}
#[derive(Debug, Deserialize, PartialEq)]
struct MixedDoc {
title: String,
count: String,
active: String,
}
#[test]
fn deserialize_mixed_field_types() {
let frame = Frame::Array(Some(vec![
Frame::Integer(1),
bs("item:1"),
Frame::Array(Some(vec![
bs("title"),
bs("Widget"),
bs("count"),
bs("42"),
bs("active"),
bs("true"),
])),
]));
let results: SearchResults<MixedDoc> = parse_search_results(frame, false).unwrap();
assert_eq!(results.docs.len(), 1);
assert_eq!(
results.docs[0].doc,
MixedDoc {
title: "Widget".into(),
count: "42".into(),
active: "true".into(),
}
);
}
#[test]
fn parse_error_on_non_array_frame() {
let frame = Frame::Integer(42);
let result: Result<SearchResults<Product>, _> = parse_search_results(frame, false);
assert!(result.is_err());
}
#[test]
fn filter_appends_to_query() {
let search = Search::new("idx", "*")
.filter("@status:{active}")
.filter("@price:[10 100]");
assert_eq!(
search.effective_query(),
"* @status:{active} @price:[10 100]"
);
}
}