Indices created in Elasticsearch 6.0.0 or later may only contain a
single mapping type. Indices created in 5.x with multiple
mapping types will continue to function as before in Elasticsearch 6.x.
Types will be deprecated in APIs in Elasticsearch 7.0.0, and completely
removed in 8.0.0.

Since the first release of Elasticsearch, each document has been stored in a
single index and assigned a single mapping type. A mapping type was used to
represent the type of document or entity being indexed, for instance a
twitter index might have a user type and a tweet type.

Each mapping type could have its own fields, so the user type might have a
full_name field, a user_name field, and an email field, while the
tweet type could have a content field, a tweeted_at field and, like the
user type, a user_name field.

Each document had a _type meta-field containing the type name, and searches
could be limited to one or more types by specifying the type name(s) in the
URL:

Initially, we spoke about an “index” being similar to a “database” in an
SQL database, and a “type” being equivalent to a
“table”.

This was a bad analogy that led to incorrect assumptions. In an SQL database,
tables are independent of each other. The columns in one table have no
bearing on columns with the same name in another table. This is not the case
for fields in a mapping type.

In an Elasticsearch index, fields that have the same name in different mapping
types are backed by the same Lucene field internally. In other words, using
the example above, the user_name field in the user type is stored in
exactly the same field as the user_name field in the tweet type, and both
user_name fields must have the same mapping (definition) in both types.

This can lead to frustration when, for example, you want deleted to be a
date field in one type and a boolean field in another type in the same
index.

On top of that, storing different entities that have few or no fields in
common in the same index leads to sparse data and interferes with Lucene’s
ability to compress documents efficiently.

For these reasons, we have decided to remove the concept of mapping types from
Elasticsearch.

The first alternative is to have an index per document type. Instead of
storing tweets and users in a single twitter index, you could store tweets
in the tweets index and users in the user index. Indices are completely
independent of each other and so there will be no conflict of field types
between indices.

This approach has two benefits:

Data is more likely to be dense and so benefit from compression techniques
used in Lucene.

The term statistics used for scoring in full text search are more likely to
be accurate because all documents in the same index represent a single
entity.

Each index can be sized appropriately for the number of documents it will
contain: you can use a smaller number of primary shards for users and a
larger number of primary shards for tweets.

Of course, there is a limit to how many primary shards can exist in a cluster
so you may not want to waste an entire shard for a collection of only a few
thousand documents. In this case, you can implement your own custom type
field which will work in a similar way to the old _type.

Let’s take the user/tweet example above. Originally, the workflow would
have looked something like this:

Previously, a parent-child relationship was represented by making one mapping
type the parent, and one or more other mapping types the children. Without
types, we can no longer use this syntax. The parent-child feature will
continue to function as before, except that the way of expressing the
relationship between documents has been changed to use the new
join field.

This is a big change for our users, so we have tried to make it as painless as
possible. The change will roll out as follows:

Elasticsearch 5.6.0

Setting index.mapping.single_type: true on an index will enable the
single-type-per-index behaviour which will be enforced in 6.0.

The join field replacement for parent-child is available
on indices created in 5.6.

Elasticsearch 6.x

Indices created in 5.x will continue to function in 6.x as they did in 5.x.

Indices created in 6.x only allow a single-type per index. Any name
can be used for the type, but there can be only one. The preferred type name
is _doc, so that index APIs have the same path as they will have in 7.0:
PUT {index}/_doc/{id} and POST {index}/_doc

The _type name can no longer be combined with the _id to form the _uid
field. The _uid field has become an alias for the _id field.

New indices no longer support the old-style of parent/child and should
use the join field instead.

The _default_ mapping type is deprecated.

In 6.7, the index creation, index template, and mapping APIs support a query
string parameter (include_type_name) which indicates whether requests and
responses should include a type name. It defaults to true, and should be set
to an explicit value to prepare to upgrade to 7.0. Not setting include_type_name
will result in a deprecation warning. Indices which don’t have an explicit type will
use the dummy type name _doc.

Elasticsearch 7.x

Specifying types in requests is deprecated. For instance, indexing a
document no longer requires a document type. The new index APIs
are PUT {index}/_doc/{id} in case of explicit ids and POST {index}/_doc
for auto-generated ids.

The include_type_name parameter in the index creation, index template,
and mapping APIs will default to false. Setting the parameter at all will
result in a deprecation warning.

The Reindex API can be used to convert multi-type indices to
single-type indices. The following examples can be used in Elasticsearch 5.6
or Elasticsearch 6.x. In 6.x, there is no need to specify
index.mapping.single_type as that is the default.

This next example adds a custom type field and sets it to the value of the
original _type. It also adds the type to the _id in case there are any
documents of different types which have conflicting IDs: