_parent fieldedit

A parent-child relationship can be established between documents in the same index by making one mapping type the parent of another:

PUT my_index
{
  "mappings": {
    "my_parent": {},
    "my_child": {
      "_parent": {
        "type": "my_parent" 
      }
    }
  }
}

PUT my_index/my_parent/1 
{
  "text": "This is a parent document"
}

PUT my_index/my_child/2?parent=1 
{
  "text": "This is a child document"
}

PUT my_index/my_child/3?parent=1 
{
  "text": "This is another child document"
}

GET my_index/my_parent/_search
{
  "query": {
    "has_child": { 
      "type": "my_child",
      "query": {
        "match": {
          "text": "child document"
        }
      }
    }
  }
}

The my_parent type is parent to the my_child type.

Index a parent document.

Index two child documents, specifying the parent document’s ID.

Find all parent documents that have children which match the query.

See the has_child and has_parent queries, the children aggregation, and inner hits for more information.

The value of the _parent field is accessible in queries, aggregations, scripts, and when sorting:

GET my_index/_search
{
  "query": {
    "terms": {
      "_parent": [ "1" ] 
    }
  },
  "aggs": {
    "parents": {
      "terms": {
        "field": "_parent", 
        "size": 10
      }
    }
  },
  "sort": [
    {
      "_parent": { 
        "order": "desc"
      }
    }
  ],
  "script_fields": {
    "parent": {
      "script": "doc['_parent']" 
    }
  }
}

Querying on the _parent field (also see the has_parent query and the has_child query)

Aggregating on the _parent field (also see the children aggregation)

Sorting on the _parent field

Accessing the _parent field in scripts (inline scripts must be enabled for this example to work)

Parent-child restrictionsedit

  • The parent and child types must be different — parent-child relationships cannot be established between documents of the same type.
  • The _parent.type setting can only point to a type that doesn’t exist yet. This means that a type cannot become a parent type after it is has been created.
  • Parent and child documents must be indexed on the same shard. The parent ID is used as the routing value for the child, to ensure that the child is indexed on the same shard as the parent. This means that the same parent value needs to be provided when getting, deleting, or updating a child document.

Global ordinalsedit

Parent-child uses global ordinals to speed up joins. Global ordinals need to be rebuilt after any change to a shard. The more parent id values are stored in a shard, the longer it takes to rebuild the global ordinals for the _parent field.

Global ordinals, by default, are built lazily: the first parent-child query or aggregation after a refresh will trigger building of global ordinals. This can introduce a significant latency spike for your users. You can use eager_global_ordinals to shift the cost of building global ordinals from query time to refresh time, by mapping the _parent field as follows:

PUT my_index
{
  "mappings": {
    "my_parent": {},
    "my_child": {
      "_parent": {
        "type": "my_parent",
        "fielddata": {
          "loading": "eager_global_ordinals"
        }
      }
    }
  }
}

The amount of heap used by global ordinals can be checked as follows:

# Per-index
GET _stats/fielddata?human&fields=_parent

# Per-node per-index
GET _nodes/stats/indices/fielddata?human&fields=_parent

Top Videos