Parent aggregation

edit

A special single bucket aggregation that selects parent documents that have the specified type, as defined in a join field.

This aggregation has a single option:

  • type - The child type that should be selected.

For example, let’s say we have an index of questions and answers. The answer type has the following join field in the mapping:

resp = client.indices.create(
    index="parent_example",
    mappings={
        "properties": {
            "join": {
                "type": "join",
                "relations": {
                    "question": "answer"
                }
            }
        }
    },
)
print(resp)
response = client.indices.create(
  index: 'parent_example',
  body: {
    mappings: {
      properties: {
        join: {
          type: 'join',
          relations: {
            question: 'answer'
          }
        }
      }
    }
  }
)
puts response
const response = await client.indices.create({
  index: "parent_example",
  mappings: {
    properties: {
      join: {
        type: "join",
        relations: {
          question: "answer",
        },
      },
    },
  },
});
console.log(response);
PUT parent_example
{
  "mappings": {
     "properties": {
       "join": {
         "type": "join",
         "relations": {
           "question": "answer"
         }
       }
     }
  }
}

The question document contain a tag field and the answer documents contain an owner field. With the parent aggregation the owner buckets can be mapped to the tag buckets in a single request even though the two fields exist in two different kinds of documents.

An example of a question document:

resp = client.index(
    index="parent_example",
    id="1",
    document={
        "join": {
            "name": "question"
        },
        "body": "I have Windows 2003 server and i bought a new Windows 2008 server...",
        "title": "Whats the best way to file transfer my site from server to a newer one?",
        "tags": [
            "windows-server-2003",
            "windows-server-2008",
            "file-transfer"
        ]
    },
)
print(resp)
response = client.index(
  index: 'parent_example',
  id: 1,
  body: {
    join: {
      name: 'question'
    },
    body: 'I have Windows 2003 server and i bought a new Windows 2008 server...',
    title: 'Whats the best way to file transfer my site from server to a newer one?',
    tags: [
      'windows-server-2003',
      'windows-server-2008',
      'file-transfer'
    ]
  }
)
puts response
const response = await client.index({
  index: "parent_example",
  id: 1,
  document: {
    join: {
      name: "question",
    },
    body: "I have Windows 2003 server and i bought a new Windows 2008 server...",
    title:
      "Whats the best way to file transfer my site from server to a newer one?",
    tags: ["windows-server-2003", "windows-server-2008", "file-transfer"],
  },
});
console.log(response);
PUT parent_example/_doc/1
{
  "join": {
    "name": "question"
  },
  "body": "<p>I have Windows 2003 server and i bought a new Windows 2008 server...",
  "title": "Whats the best way to file transfer my site from server to a newer one?",
  "tags": [
    "windows-server-2003",
    "windows-server-2008",
    "file-transfer"
  ]
}

Examples of answer documents:

resp = client.index(
    index="parent_example",
    id="2",
    routing="1",
    document={
        "join": {
            "name": "answer",
            "parent": "1"
        },
        "owner": {
            "location": "Norfolk, United Kingdom",
            "display_name": "Sam",
            "id": 48
        },
        "body": "Unfortunately you're pretty much limited to FTP...",
        "creation_date": "2009-05-04T13:45:37.030"
    },
)
print(resp)

resp1 = client.index(
    index="parent_example",
    id="3",
    routing="1",
    refresh=True,
    document={
        "join": {
            "name": "answer",
            "parent": "1"
        },
        "owner": {
            "location": "Norfolk, United Kingdom",
            "display_name": "Troll",
            "id": 49
        },
        "body": "Use Linux...",
        "creation_date": "2009-05-05T13:45:37.030"
    },
)
print(resp1)
response = client.index(
  index: 'parent_example',
  id: 2,
  routing: 1,
  body: {
    join: {
      name: 'answer',
      parent: '1'
    },
    owner: {
      location: 'Norfolk, United Kingdom',
      display_name: 'Sam',
      id: 48
    },
    body: "Unfortunately you're pretty much limited to FTP...",
    creation_date: '2009-05-04T13:45:37.030'
  }
)
puts response

response = client.index(
  index: 'parent_example',
  id: 3,
  routing: 1,
  refresh: true,
  body: {
    join: {
      name: 'answer',
      parent: '1'
    },
    owner: {
      location: 'Norfolk, United Kingdom',
      display_name: 'Troll',
      id: 49
    },
    body: 'Use Linux...',
    creation_date: '2009-05-05T13:45:37.030'
  }
)
puts response
const response = await client.index({
  index: "parent_example",
  id: 2,
  routing: 1,
  document: {
    join: {
      name: "answer",
      parent: "1",
    },
    owner: {
      location: "Norfolk, United Kingdom",
      display_name: "Sam",
      id: 48,
    },
    body: "Unfortunately you're pretty much limited to FTP...",
    creation_date: "2009-05-04T13:45:37.030",
  },
});
console.log(response);

const response1 = await client.index({
  index: "parent_example",
  id: 3,
  routing: 1,
  refresh: "true",
  document: {
    join: {
      name: "answer",
      parent: "1",
    },
    owner: {
      location: "Norfolk, United Kingdom",
      display_name: "Troll",
      id: 49,
    },
    body: "Use Linux...",
    creation_date: "2009-05-05T13:45:37.030",
  },
});
console.log(response1);
PUT parent_example/_doc/2?routing=1
{
  "join": {
    "name": "answer",
    "parent": "1"
  },
  "owner": {
    "location": "Norfolk, United Kingdom",
    "display_name": "Sam",
    "id": 48
  },
  "body": "<p>Unfortunately you're pretty much limited to FTP...",
  "creation_date": "2009-05-04T13:45:37.030"
}

PUT parent_example/_doc/3?routing=1&refresh
{
  "join": {
    "name": "answer",
    "parent": "1"
  },
  "owner": {
    "location": "Norfolk, United Kingdom",
    "display_name": "Troll",
    "id": 49
  },
  "body": "<p>Use Linux...",
  "creation_date": "2009-05-05T13:45:37.030"
}

The following request can be built that connects the two together:

resp = client.search(
    index="parent_example",
    size="0",
    aggs={
        "top-names": {
            "terms": {
                "field": "owner.display_name.keyword",
                "size": 10
            },
            "aggs": {
                "to-questions": {
                    "parent": {
                        "type": "answer"
                    },
                    "aggs": {
                        "top-tags": {
                            "terms": {
                                "field": "tags.keyword",
                                "size": 10
                            }
                        }
                    }
                }
            }
        }
    },
)
print(resp)
response = client.search(
  index: 'parent_example',
  size: 0,
  body: {
    aggregations: {
      "top-names": {
        terms: {
          field: 'owner.display_name.keyword',
          size: 10
        },
        aggregations: {
          "to-questions": {
            parent: {
              type: 'answer'
            },
            aggregations: {
              "top-tags": {
                terms: {
                  field: 'tags.keyword',
                  size: 10
                }
              }
            }
          }
        }
      }
    }
  }
)
puts response
const response = await client.search({
  index: "parent_example",
  size: 0,
  aggs: {
    "top-names": {
      terms: {
        field: "owner.display_name.keyword",
        size: 10,
      },
      aggs: {
        "to-questions": {
          parent: {
            type: "answer",
          },
          aggs: {
            "top-tags": {
              terms: {
                field: "tags.keyword",
                size: 10,
              },
            },
          },
        },
      },
    },
  },
});
console.log(response);
POST parent_example/_search?size=0
{
  "aggs": {
    "top-names": {
      "terms": {
        "field": "owner.display_name.keyword",
        "size": 10
      },
      "aggs": {
        "to-questions": {
          "parent": {
            "type" : "answer" 
          },
          "aggs": {
            "top-tags": {
              "terms": {
                "field": "tags.keyword",
                "size": 10
              }
            }
          }
        }
      }
    }
  }
}

The type points to type / mapping with the name answer.

The above example returns the top answer owners and per owner the top question tags.

Possible response:

{
  "took": 9,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total" : {
      "value": 3,
      "relation": "eq"
    },
    "max_score": null,
    "hits": []
  },
  "aggregations": {
    "top-names": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 0,
      "buckets": [
        {
          "key": "Sam",
          "doc_count": 1, 
          "to-questions": {
            "doc_count": 1, 
            "top-tags": {
              "doc_count_error_upper_bound": 0,
              "sum_other_doc_count": 0,
              "buckets": [
                {
                  "key": "file-transfer",
                  "doc_count": 1
                },
                {
                  "key": "windows-server-2003",
                  "doc_count": 1
                },
                {
                  "key": "windows-server-2008",
                  "doc_count": 1
                }
              ]
            }
          }
        },
        {
          "key": "Troll",
          "doc_count": 1,
          "to-questions": {
            "doc_count": 1,
            "top-tags": {
              "doc_count_error_upper_bound": 0,
              "sum_other_doc_count": 0,
              "buckets": [
                {
                  "key": "file-transfer",
                  "doc_count": 1
                },
                {
                  "key": "windows-server-2003",
                  "doc_count": 1
                },
                {
                  "key": "windows-server-2008",
                  "doc_count": 1
                }
              ]
            }
          }
        }
      ]
    }
  }
}

The number of answer documents with the tag Sam, Troll, etc.

The number of question documents that are related to answer documents with the tag Sam, Troll, etc.