Module elastic::types::document

Base requirements for indexable document mappings.

Structures that can be indexed in Elasticsearch should implement DocumentType. The DocumentType is composed of typical mapping metadata, as well as the mapping for each of its properties.

Documents can be mapped as indexable types, or as an object field on another type.

Examples

Define your Elasticsearch types using Plain Old Rust Structures.

Derive Mapping

Mapping can be generated by deriving ElasticType on a struct:

#[derive(Serialize, ElasticType)]
pub struct MyType {
    pub my_date: Date<DefaultDateMapping>,
    pub my_string: String,
    pub my_num: i32
}

This will produce the following field mapping:

{
    "type": "nested",
    "properties": {
        "my_date": {
            "type": "date",
            "format": "basic_date_time"
        },
        "my_string": {
            "type": "text",
            "fields": {
                "keyword":{
                    "type":"keyword",
                    "ignore_above":256
                }
            }
        },
        "my_num": {
            "type": "integer"
        }
    }
}

It's also possible to adjust the mapping using the #[elastic] attribute.

Override Default Mapping Properties

You can override the mapping meta properties for an object by providing your own mapping type with #[elastic(mapping="{TypeName}")]:

#[derive(Serialize, ElasticType)]
#[elastic(mapping="MyTypeMapping")]
pub struct MyType {
    pub my_date: Date<DefaultDateMapping>,
    pub my_string: String,
    pub my_num: i32
}

#[derive(Default)]
pub struct MyTypeMapping;
impl DocumentMapping for MyTypeMapping {
    //Give your own name to a type
    fn name() -> &'static str { "my_type" }

    fn data_type() -> &'static str { OBJECT_DATATYPE }
}

This will produce the following field mapping:

{
    "type": "object",
    "properties": {
        "my_date": {
            "type": "date",
            "format": "basic_date_time"
        },
        "my_string": {
            "type": "text",
            "fields": {
                "keyword":{
                    "type":"keyword",
                    "ignore_above":256
                }
            }
        },
        "my_num": {
            "type": "integer"
        }
    }
}

Ignore or Rename Fields

You can then serialise type mappings with #[serde] attributes:

#[derive(ElasticType, Serialize)]
pub struct MyType {
    #[serde(rename="my_renamed_date")]
    pub my_date: Date<DefaultDateMapping>,
    #[serde(skip_serializing)]
    pub ignored: String,
    pub my_num: i32
}

NOTE: Fields with a #[serde(skip_deserializing)] attribute will still be mapped, because they can still be indexed in Elasticsearch.

Limitations

Automatically deriving mapping has the following limitations:

• Generics aren't supported by auto deriving. So you can't #[derive(ElasticType)] on MyType<T>.
• Mapping types can't be shared. This is because they need to map the type fields, so are specific to that type. So you can't share MyTypeMapping between MyType and MyOtherType.

Links

• Field Types
• Document Types

Modules

mapping	Mapping for Elasticsearch document types.
prelude	Includes all types for document types.

Structs

IndexDocumentMapping	A wrapper type for serialising user types.
ValueDocumentMapping	Mapping for an anonymous json object.

Traits

DocumentType

The additional fields available to an indexable Elasticsearch type.