Skip to main content

druid_io/query/
search.rs

1use super::definitions::Filter;
2use super::definitions::Granularity;
3use super::definitions::SortingOrder;
4use super::DataSource;
5use serde::{Deserialize, Serialize};
6
7#[derive(Serialize, Deserialize, Debug)]
8#[serde(rename_all = "camelCase")]
9#[serde(tag = "queryType", rename = "search")]
10pub struct Search {
11    pub data_source: DataSource,
12    pub granularity: Granularity,
13    pub filter: Option<Filter>,
14    pub limit: usize,
15    pub intervals: Vec<String>,
16    pub search_dimensions: Vec<String>,
17    pub query: SearchQuerySpec,
18    pub sort: Option<SortingOrder>,
19    pub context: std::collections::HashMap<String, String>,
20}
21
22#[derive(Serialize, Deserialize, Debug)]
23#[serde(rename_all = "snake_case")]
24#[serde(tag = "type")]
25pub enum SearchQuerySpec {
26    #[serde(rename_all = "camelCase")]
27    InsensitiveContains { value: String },
28    #[serde(rename_all = "camelCase")]
29    Fragment {
30        case_sensitive: bool,
31        values: Vec<String>,
32    },
33    #[serde(rename_all = "camelCase")]
34    Contains { case_sensitive: bool, value: String },
35    #[serde(rename_all = "camelCase")]
36    Regex { pattern: String },
37}
38
39impl SearchQuerySpec {
40    pub fn contains_insensitive(value: &str) -> Self {
41        SearchQuerySpec::InsensitiveContains {
42            value: value.to_string(),
43        }
44    }
45
46    pub fn constain(value: &str, case_sensitive: bool) -> Self {
47        SearchQuerySpec::Contains {
48            value: value.to_string(),
49            case_sensitive: case_sensitive,
50        }
51    }
52    pub fn fragment(values: Vec<&str>, case_sensitive: bool) -> Self {
53        SearchQuerySpec::Fragment {
54            values: values.iter().map(|s| s.to_string()).collect(),
55            case_sensitive: case_sensitive,
56        }
57    }
58
59    pub fn regrex(pattern: &str) -> Self {
60        SearchQuerySpec::Regex {
61            pattern: pattern.to_string(),
62        }
63    }
64}