[−][src]Trait elastic_types::string::text::mapping::TextMapping

pub trait TextMapping {
    fn analyzer() -> Option<&'static str> { ... }
    fn boost() -> Option<f32> { ... }
    fn eager_global_ordinals() -> Option<bool> { ... }
    fn fielddata() -> Option<bool> { ... }
    fn fielddata_frequency_filter() -> Option<FieldDataFrequencyFilter> { ... }
    fn fields() -> Option<BTreeMap<&'static str, StringField>> { ... }
    fn include_in_all() -> Option<bool> { ... }
    fn ignore_above() -> Option<u32> { ... }
    fn index() -> Option<bool> { ... }
    fn index_options() -> Option<IndexOptions> { ... }
    fn norms() -> Option<bool> { ... }
    fn position_increment_gap() -> Option<u32> { ... }
    fn store() -> Option<bool> { ... }
    fn search_analyzer() -> Option<&'static str> { ... }
    fn search_quote_analyzer() -> Option<&'static str> { ... }
    fn similarity() -> Option<&'static str> { ... }
    fn term_vector() -> Option<TermVector> { ... }
}

The base requirements for mapping a string type.

Custom mappings can be defined by implementing TextMapping.

Examples

Define a custom TextMapping:

#[derive(Default)]
struct MyStringMapping;
impl TextMapping for MyStringMapping {
    //Overload the mapping functions here
    fn boost() -> Option<f32> {
        Some(1.5)
    }
}

This will produce the following mapping:

{
    "type": "text",
    "boost": 1.5
}

Provided methods

`fn analyzer() -> Option<&'static str>`

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 boost() -> Option<f32>`

Field-level index time boosting. Accepts a floating point number, defaults to 1.0.

`fn eager_global_ordinals() -> 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.

`fn fielddata() -> Option<bool>`

Can the field use in-memory fielddata for sorting, aggregations, or scripting? Accepts true or false (default).

`fn fielddata_frequency_filter() -> Option<FieldDataFrequencyFilter>`

Expert settings which allow to decide which values to load in memory when fielddata is enabled. By default all values are loaded.

`fn fields() -> Option<BTreeMap<&'static str, StringField>>`

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 structs, so you don't need to define a separate type to map them:

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 include_in_all() -> 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.

`fn ignore_above() -> Option<u32>`

The maximum number of characters to index. Any characters over this length will be ignored.

`fn index() -> Option<bool>`

Should the field be searchable? Accepts true (default) or false.

`fn index_options() -> Option<IndexOptions>`

What information should be stored in the index, for search and highlighting purposes. Defaults to Positions.

`fn norms() -> Option<bool>`

Whether field-length should be taken into account when scoring queries. Accepts true (default) or false.

`fn position_increment_gap() -> Option<u32>`

The number of fake term position which should be inserted between each element of an array of strings. Defaults to the position_increment_gap configured on the analyzer which defaults to 100. 100 was chosen because it prevents phrase queries with reasonably large slops (less than 100) from matching terms across field values.