1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361
/*! Mapping for the Elasticsearch `keyword` type. */ use std::collections::BTreeMap; use serde::{Serialize, Serializer}; use serde::ser::SerializeStruct; use string::mapping::{IndexOptions, StringField}; use private::field::FieldMapping; /** A field that will be mapped as a `keyword`. */ pub trait KeywordFieldType<TMapping> {} /** The base requirements for mapping a `string` type. Custom mappings can be defined by implementing `KeywordMapping`. # Examples Define a custom `KeywordMapping`: ``` # #[macro_use] # extern crate elastic_types; # extern crate serde; # use elastic_types::prelude::*; #[derive(Default)] struct MyStringMapping; impl KeywordMapping for MyStringMapping { //Overload the mapping functions here fn boost() -> Option<f32> { Some(1.5) } } # fn main() {} ``` This will produce the following mapping: ``` # #[macro_use] # extern crate json_str; # #[macro_use] # extern crate elastic_types; # extern crate serde; # #[cfg(feature = "nightly")] # extern crate serde_json; # use elastic_types::prelude::*; # #[derive(Default)] # struct MyStringMapping; # impl KeywordMapping for MyStringMapping { # //Overload the mapping functions here # fn boost() -> Option<f32> { # Some(1.5) # } # } # fn main() { # let json = json_str!( { "type": "keyword", "boost": 1.5 } # ); # #[cfg(feature = "nightly")] # let mapping = serde_json::to_string(&DocumentField::from(MyStringMapping)).unwrap(); # #[cfg(not(feature = "nightly"))] # let mapping = json.clone(); # assert_eq!(json, mapping); # } ``` */ pub trait KeywordMapping where Self: Default, { /** The analyzer which should be used for analyzed string fields, both at index-time and at search-time (unless overridden by the `search_analyzer`). Defaults to the default index analyzer, or the `standard` analyzer. */ fn analyzer() -> Option<&'static str> { None } /** Field-level index time boosting. Accepts a floating point number, defaults to `1.0`. */ fn boost() -> Option<f32> { None } /** Should the field be stored on disk in a column-stride fashion, so that it can later be used for sorting, aggregations, or scripting? Accepts `true` (default) or `false`. */ fn doc_values() -> Option<bool> { None } /** Should global ordinals be loaded eagerly on refresh? Accepts `true` or `false` (default). Enabling this is a good idea on fields that are frequently used for (significant) terms aggregations. */ fn eager_global_ordinals() -> Option<bool> { None } /** Multi-fields allow the same string value to be indexed in multiple ways for different purposes, such as one field for search and a multi-field for sorting and aggregations, or the same string value analyzed by different analyzers. # Examples Subfields are provided as simple `struct`s, so you don't need to define a separate type to map them: ``` # #[macro_use] # extern crate elastic_types; # extern crate serde; # use std::collections::BTreeMap; # use elastic_types::prelude::*; # #[derive(Default)] # struct MyStringMapping; # impl KeywordMapping for MyStringMapping { fn fields() -> Option<BTreeMap<&'static str, StringField>> { let mut fields = BTreeMap::new(); //Add a `token_count` as a sub field fields.insert("count", StringField::TokenCount( ElasticTokenCountFieldMapping::default()) ); //Add a `completion` suggester as a sub field fields.insert("comp", StringField::Completion( ElasticCompletionFieldMapping::default()) ); Some(fields) } # } # fn main() {} ``` */ fn fields() -> Option<BTreeMap<&'static str, StringField>> { None } /** Whether or not the field value should be included in the `_all` field? Accepts true or false. Defaults to `false` if index is set to `no`, or if a parent object field sets `include_in_all` to false. Otherwise defaults to `true`. */ fn include_in_all() -> Option<bool> { None } /** The maximum number of characters to index. Any characters over this length will be ignored. */ fn ignore_above() -> Option<u32> { None } /** Should the field be searchable? Accepts `true` (default) or `false`. */ fn index() -> Option<bool> { None } /** What information should be stored in the index, for search and highlighting purposes. Defaults to `Positions`. */ fn index_options() -> Option<IndexOptions> { None } /** Whether field-length should be taken into account when scoring queries. Accepts `true` (default) or `false`. */ fn norms() -> Option<bool> { None } /** Accepts a `string` value which is substituted for any explicit null values. Defaults to `null`, which means the field is treated as missing. */ fn null_value() -> Option<&'static str> { None } /** Whether the field value should be stored and retrievable separately from the `_source` field. Accepts `true` or `false` (default). */ fn store() -> Option<bool> { None } /** The analyzer that should be used at search time on analyzed fields. Defaults to the analyzer setting. */ fn search_analyzer() -> Option<&'static str> { None } /** Which scoring algorithm or similarity should be used. Defaults to `"classic"`, which uses TF/IDF. */ fn similarity() -> Option<&'static str> { None } } /** Default mapping for `bool`. */ #[derive(PartialEq, Debug, Default, Clone, Copy)] pub struct DefaultKeywordMapping; impl KeywordMapping for DefaultKeywordMapping {} /** A multi-field string mapping. */ #[derive(Debug, Default, Clone, Copy)] pub struct KeywordFieldMapping { /** The analyzer which should be used for analyzed string fields, both at index-time and at search-time (unless overridden by the `search_analyzer`). Defaults to the default index analyzer, or the `standard` analyzer. */ pub analyzer: Option<&'static str>, /** Should the field be stored on disk in a column-stride fashion, so that it can later be used for sorting, aggregations, or scripting? Accepts `true` (default) or `false`. */ pub doc_values: Option<bool>, /** Should global ordinals be loaded eagerly on refresh? Accepts `true` or `false` (default). Enabling this is a good idea on fields that are frequently used for (significant) terms aggregations. */ pub eager_global_ordinals: Option<bool>, /** Whether or not the field value should be included in the `_all` field? Accepts true or false. Defaults to `false` if index is set to `no`, or if a parent object field sets `include_in_all` to false. Otherwise defaults to `true`. */ pub include_in_all: Option<bool>, /** The maximum number of characters to index. Any characters over this length will be ignored. */ pub ignore_above: Option<u32>, /** Should the field be searchable? Accepts `true` (default) or `false`. */ pub index: Option<bool>, /** What information should be stored in the index, for search and highlighting purposes. Defaults to `Positions`. */ pub index_options: Option<IndexOptions>, /** Whether field-length should be taken into account when scoring queries. Accepts `true` (default) or `false`. */ pub norms: Option<bool>, /** Whether the field value should be stored and retrievable separately from the `_source` field. Accepts `true` or `false` (default). */ pub store: Option<bool>, /** The analyzer that should be used at search time on analyzed fields. Defaults to the analyzer setting. */ pub search_analyzer: Option<&'static str>, /** Which scoring algorithm or similarity should be used. Defaults to `"classic"`, which uses TF/IDF. */ pub similarity: Option<&'static str>, } impl Serialize for KeywordFieldMapping { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, { let mut state = try!(serializer.serialize_struct("mapping", 12)); try!(state.serialize_field("type", DefaultKeywordMapping::data_type())); ser_field!(state, "analyzer", self.analyzer); ser_field!(state, "doc_values", self.doc_values); ser_field!(state, "eager_global_ordinals", self.eager_global_ordinals); ser_field!(state, "include_in_all", self.include_in_all); ser_field!(state, "ignore_above", self.ignore_above); ser_field!(state, "index", self.index); ser_field!(state, "index_options", self.index_options); ser_field!(state, "norms", self.norms); ser_field!(state, "store", self.store); ser_field!(state, "search_analyzer", self.search_analyzer); ser_field!(state, "similarity", self.similarity); state.end() } } mod private { use serde::{Serialize, Serializer}; use serde::ser::SerializeStruct; use private::field::{DocumentField, FieldMapping, FieldType}; use super::{KeywordFieldType, KeywordMapping}; #[derive(Default)] pub struct KeywordPivot; impl<TField, TMapping> FieldType<TMapping, KeywordPivot> for TField where TField: KeywordFieldType<TMapping> + Serialize, TMapping: KeywordMapping, { } impl<TMapping> FieldMapping<KeywordPivot> for TMapping where TMapping: KeywordMapping, { type DocumentField = DocumentField<TMapping, KeywordPivot>; fn data_type() -> &'static str { "keyword" } } impl<TMapping> Serialize for DocumentField<TMapping, KeywordPivot> where TMapping: FieldMapping<KeywordPivot> + KeywordMapping, { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, { let mut state = try!(serializer.serialize_struct("mapping", 15)); try!(state.serialize_field("type", TMapping::data_type())); ser_field!(state, "boost", TMapping::boost()); ser_field!(state, "analyzer", TMapping::analyzer()); ser_field!(state, "doc_values", TMapping::doc_values()); ser_field!( state, "eager_global_ordinals", TMapping::eager_global_ordinals() ); ser_field!(state, "fields", TMapping::fields()); ser_field!(state, "include_in_all", TMapping::include_in_all()); ser_field!(state, "ignore_above", TMapping::ignore_above()); ser_field!(state, "index", TMapping::index()); ser_field!(state, "index_options", TMapping::index_options()); ser_field!(state, "norms", TMapping::norms()); ser_field!(state, "null_value", TMapping::null_value()); ser_field!(state, "store", TMapping::store()); ser_field!(state, "search_analyzer", TMapping::search_analyzer()); ser_field!(state, "similarity", TMapping::similarity()); state.end() } } }