feat(fields): filter field with "contains" behavior

Author: Totodore

quickwit/Cargo.toml

@@ -394,7 +394,7 @@ sasl2-sys = { git = "https://github.com/quickwit-oss/rust-sasl/", rev = "085a4c7
 #tracing-subscriber = { git = "https://github.com/trinity-1686a/tracing.git", rev = "6806cac3" }
 
 [profile.dev]
-debug = false
+debug = true
 
 [profile.release]
 lto = "thin"

quickwit/quickwit-search/src/list_fields.rs

@@ -279,25 +279,37 @@ fn matches_any_pattern(field_name: &str, field_patterns: &[FieldPattern]) -> boo
 enum FieldPattern {
     Match { field: String },
     Wildcard { prefix: String, suffix: String },
+    Contains { infix: String },
 }
 
 impl FromStr for FieldPattern {
     type Err = crate::SearchError;
 
     fn from_str(field_pattern: &str) -> crate::Result<Self> {
-        match field_pattern.find('*') {
+        if field_pattern.starts_with('*') && field_pattern.ends_with('*') {
+            let infix = field_pattern.trim_matches('*').to_string();
+            if infix.contains('*') {
+                return Err(crate::SearchError::InvalidArgument(format!(
+                    "invalid field pattern `{field_pattern}`: 'contains' type patterns can't have a wildcard in the middle"
+                )));
+            }
+            return Ok(Self::Contains { infix });
+        }
+
+        match field_pattern.split_once('*') {
             None => Ok(FieldPattern::Match {
                 field: field_pattern.to_string(),
             }),
-            Some(pos) => {
-                let prefix = field_pattern[..pos].to_string();
-                let suffix = field_pattern[pos + 1..].to_string();
+            Some((prefix, suffix)) => {
                 if suffix.contains("*") {
                     return Err(crate::SearchError::InvalidArgument(format!(
                         "invalid field pattern `{field_pattern}`: we only support one wildcard"
                     )));
                 }
-                Ok(FieldPattern::Wildcard { prefix, suffix })
+                Ok(FieldPattern::Wildcard {
+                    prefix: prefix.to_string(),
+                    suffix: suffix.to_string(),
+                })
             }
         }
     }
@@ -310,6 +322,7 @@ impl FieldPattern {
             FieldPattern::Wildcard { prefix, suffix } => {
                 field_name.starts_with(prefix) && field_name.ends_with(suffix)
             }
+            FieldPattern::Contains { infix } => field_name.contains(infix),
         }
     }
 }
@@ -331,7 +344,7 @@ pub async fn leaf_list_fields(
 
     // If no splits, return empty response
     if split_ids.is_empty() {
-        return Ok(ListFieldsResponse { fields: Vec::new() });
+        return Ok(ListFieldsResponse::default());
     }
 
     // Get fields from all splits
@@ -1032,6 +1045,15 @@ mod tests {
         assert!(!inner_pattern.matches("tito"));
         assert!(inner_pattern.matches("towhateverti"));
 
+        let contains_pattern = FieldPattern::from_str("*my_field*").unwrap();
+        assert!(!contains_pattern.matches(""));
+        assert!(!contains_pattern.matches("my_fiel"));
+        assert!(contains_pattern.matches("my_field"));
+        assert!(contains_pattern.matches("prefix_my_field"));
+        assert!(contains_pattern.matches("my_field_suffix"));
+        assert!(contains_pattern.matches("prefix_my_field_suffix"));
+
         assert!(FieldPattern::from_str("to**").is_err());
+        assert!(FieldPattern::from_str("*a*b*").is_err());
     }
 }

quickwit/quickwit-serve/src/search_api/rest_handler.rs

@@ -271,11 +271,38 @@ pub struct ListFieldsQueryString {
     /// The results with rank [start_offset..start_offset + max_hits) are returned
     #[serde(default)] // Default to 0. (We are 0-indexed)
     pub start_offset: u64,
+    /// Query text. The query language is that of tantivy.
+    #[serde(default)]
+    pub query: String,
     /// The output format.
     #[serde(default)]
     pub format: BodyFormat,
 }
 
+pub fn list_fields_request_from_api_request(
+    index_id_patterns: Vec<String>,
+    request: ListFieldsQueryString,
+) -> Result<ListFieldsRequest, SearchError> {
+    let query_ast = query_ast_from_user_text(&request.query, None);
+    let query_ast = serde_json::to_string(&query_ast)?;
+
+    let req = ListFieldsRequest {
+        end_timestamp: request.end_timestamp,
+        start_timestamp: request.start_timestamp,
+        fields: if !request.fields.is_empty() {
+            request.fields.split(',').map(String::from).collect()
+        } else {
+            Default::default()
+        },
+        index_id_patterns,
+        max_fields: request.max_fields,
+        start_offset: request.start_offset,
+        query_ast: Some(query_ast),
+    };
+
+    Ok(req)
+}
+
 pub fn search_request_from_api_request(
     index_id_patterns: Vec<String>,
     search_request: SearchRequestQueryString,
@@ -404,19 +431,12 @@ async fn list_fields(
     request: ListFieldsQueryString,
     search_service: Arc<dyn SearchService>,
 ) -> impl warp::Reply {
-    let req = ListFieldsRequest {
-        end_timestamp: request.end_timestamp,
-        start_timestamp: request.start_timestamp,
-        fields: if !request.fields.is_empty() {
-            request.fields.split(',').map(String::from).collect()
-        } else {
-            Default::default()
-        },
-        index_id_patterns,
-        max_fields: request.max_fields,
-        start_offset: request.start_offset,
-    };
-    let result = search_service.root_list_fields(req).await;
+    let result: Result<_, SearchError> = async {
+        let request = list_fields_request_from_api_request(index_id_patterns, request)?;
+        search_service.root_list_fields(request).await
+    }
+    .await;
+
     into_rest_api_response(result, BodyFormat::Json)
 }