qdrant_client/builders/
text_index_params_builder.rs

1use crate::qdrant::*;
2
3#[derive(Clone)]
4pub struct TextIndexParamsBuilder {
5    /// Tokenizer type
6    pub(crate) tokenizer: Option<i32>,
7    /// If true - all tokens will be lowercase
8    pub(crate) lowercase: Option<Option<bool>>,
9    /// Minimal token length
10    pub(crate) min_token_len: Option<Option<u64>>,
11    /// Maximal token length
12    pub(crate) max_token_len: Option<Option<u64>>,
13    /// If true - store index on disk.
14    pub(crate) on_disk: Option<Option<bool>>,
15    pub(crate) stopwords: Option<Option<StopwordsSet>>,
16    /// If true - support phrase matching.
17    pub(crate) phrase_matching: Option<Option<bool>>,
18    /// Set an algorithm for stemming.
19    pub(crate) stemmer: Option<Option<StemmingAlgorithm>>,
20}
21
22impl TextIndexParamsBuilder {
23    pub fn new(tokenizer: TokenizerType) -> Self {
24        let mut builder = Self::create_empty();
25        builder.tokenizer = Some(tokenizer.into());
26        builder
27    }
28
29    /// Tokenizer type
30    #[allow(unused_mut)]
31    pub fn tokenizer(self, value: i32) -> Self {
32        let mut new = self;
33        new.tokenizer = Option::Some(value);
34        new
35    }
36    /// If true - all tokens will be lowercase
37    #[allow(unused_mut)]
38    pub fn lowercase(self, value: bool) -> Self {
39        let mut new = self;
40        new.lowercase = Option::Some(Option::Some(value));
41        new
42    }
43    /// Minimal token length
44    #[allow(unused_mut)]
45    pub fn min_token_len(self, value: u64) -> Self {
46        let mut new = self;
47        new.min_token_len = Option::Some(Option::Some(value));
48        new
49    }
50    /// Maximal token length
51    #[allow(unused_mut)]
52    pub fn max_token_len(self, value: u64) -> Self {
53        let mut new = self;
54        new.max_token_len = Option::Some(Option::Some(value));
55        new
56    }
57    /// If true - store index on disk.
58    #[allow(unused_mut)]
59    pub fn on_disk(self, value: bool) -> Self {
60        let mut new = self;
61        new.on_disk = Option::Some(Option::Some(value));
62        new
63    }
64
65    /// Stopwords for a single language for the text index
66    pub fn stopwords_language(self, language: String) -> Self {
67        let mut new = self;
68        let stopwords_set = StopwordsSet {
69            languages: vec![language],
70            custom: vec![],
71        };
72        new.stopwords = Some(Some(stopwords_set));
73        new
74    }
75
76    /// Stopwords for the text index
77    pub fn stopwords(self, stopwords_set: StopwordsSet) -> Self {
78        let mut new = self;
79        new.stopwords = Some(Some(stopwords_set));
80        new
81    }
82
83    /// If true - support phrase matching. Default is false.
84    pub fn phrase_matching(self, phrase_matching: bool) -> Self {
85        let mut new = self;
86        new.phrase_matching = Some(Some(phrase_matching));
87        new
88    }
89
90    /// Set snowball stemmer with the provided language
91    pub fn snowball_stemmer(self, language: String) -> Self {
92        let mut new: TextIndexParamsBuilder = self;
93        let stemmer = StemmingAlgorithm {
94            stemming_params: Some(stemming_algorithm::StemmingParams::Snowball(
95                SnowballParams { language },
96            )),
97        };
98        new.stemmer = Some(Some(stemmer));
99        new
100    }
101
102    /// Set an algorithm for stemming.
103    pub fn stemmer(self, stemming_params: stemming_algorithm::StemmingParams) -> Self {
104        let mut new = self;
105        let stemmer = StemmingAlgorithm {
106            stemming_params: Some(stemming_params),
107        };
108        new.stemmer = Some(Some(stemmer));
109        new
110    }
111
112    fn build_inner(self) -> Result<TextIndexParams, TextIndexParamsBuilderError> {
113        Ok(TextIndexParams {
114            tokenizer: match self.tokenizer {
115                Some(value) => value,
116                None => {
117                    return Result::Err(core::convert::Into::into(
118                        ::derive_builder::UninitializedFieldError::from("tokenizer"),
119                    ));
120                }
121            },
122            lowercase: self.lowercase.unwrap_or_default(),
123            min_token_len: self.min_token_len.unwrap_or_default(),
124            max_token_len: self.max_token_len.unwrap_or_default(),
125            on_disk: self.on_disk.unwrap_or_default(),
126            stopwords: self.stopwords.unwrap_or_default(),
127            phrase_matching: self.phrase_matching.unwrap_or_default(),
128            stemmer: self.stemmer.unwrap_or_default(),
129        })
130    }
131
132    /// Create an empty builder, with all fields set to `None` or `PhantomData`.
133    fn create_empty() -> Self {
134        Self {
135            tokenizer: Default::default(),
136            lowercase: Default::default(),
137            min_token_len: Default::default(),
138            max_token_len: Default::default(),
139            on_disk: Default::default(),
140            stopwords: Default::default(),
141            phrase_matching: Default::default(),
142            stemmer: Default::default(),
143        }
144    }
145}
146
147impl From<TextIndexParamsBuilder> for TextIndexParams {
148    fn from(value: TextIndexParamsBuilder) -> Self {
149        value.build_inner().unwrap_or_else(|_| {
150            panic!(
151                "Failed to convert {0} to {1}",
152                "TextIndexParamsBuilder", "TextIndexParams"
153            )
154        })
155    }
156}
157
158impl TextIndexParamsBuilder {
159    /// Builds the desired type. Can often be omitted.
160    pub fn build(self) -> TextIndexParams {
161        self.build_inner().unwrap_or_else(|_| {
162            panic!(
163                "Failed to build {0} into {1}",
164                "TextIndexParamsBuilder", "TextIndexParams"
165            )
166        })
167    }
168}
169
170#[non_exhaustive]
171#[derive(Debug)]
172pub enum TextIndexParamsBuilderError {
173    /// Uninitialized field
174    UninitializedField(&'static str),
175    /// Custom validation error
176    ValidationError(String),
177}
178
179// Implementing the Display trait for better error messages
180impl std::fmt::Display for TextIndexParamsBuilderError {
181    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
182        match self {
183            Self::UninitializedField(field) => {
184                write!(f, "`{field}` must be initialized")
185            }
186            Self::ValidationError(error) => write!(f, "{error}"),
187        }
188    }
189}
190
191// Implementing the Error trait
192impl std::error::Error for TextIndexParamsBuilderError {}
193
194// Implementing From trait for conversion from UninitializedFieldError
195impl From<derive_builder::UninitializedFieldError> for TextIndexParamsBuilderError {
196    fn from(error: derive_builder::UninitializedFieldError) -> Self {
197        Self::UninitializedField(error.field_name())
198    }
199}
200
201// Implementing From trait for conversion from String
202impl From<String> for TextIndexParamsBuilderError {
203    fn from(error: String) -> Self {
204        Self::ValidationError(error)
205    }
206}
qdrant_client/builders/text_index_params_builder.rs

qdrant_client/builders/
text_index_params_builder.rs
