Elasticsearch Elasticsearch Nested Filter

By Opster Team

Updated: Aug 24, 2023

| 2 min read

Introduction

This article delves into the intricacies of the Elasticsearch Nested Filter, its application, and how to optimize it for improved query performance.

Nested objects in Elasticsearch are documents themselves, which can contain other nested objects leading to a multi-level nested structure. The Nested Filter comes into play when dealing with such complex data structures. It allows you to run queries on these nested objects, treating each one as a separate document.

How to use the Elasticsearch Nested Filter effectively.

Step 1: Defining nested fields

Before you can use the Nested Filter, you need to define your nested fields in your mappings. Here’s an example:

PUT /my_index
{
  "mappings": {
    "properties": {
      "user": {
        "type": "nested" 
      }
    }
  }
}

In this example, ‘user’ is defined as a nested field.

Step 2: Indexing nested documents

Once you’ve defined your nested fields, you can index nested documents. Here’s an example:

PUT /my_index/_doc/1
{
  "group" : "fans",
  "user" : [
    {
      "first" : "John",
      "last" :  "Smith"
    },
    {
      "first" : "Alice",
      "last" :  "White"
    }
  ]
}

In this example, ‘user’ is a nested array containing two objects each stored in separate hidden documents different from the root-level document.

Step 3: Querying nested documents

To query nested documents, you need to use the nested query. Here’s an example:

GET /my_index/_search
{
  "query": {
    "nested": {
      "path": "user",
      "query": {
        "bool": {
          "must": [
            { "match": { "user.first": "Alice" }},
            { "match": { "user.last":  "White" }}
          ]
        }
      }
    }
  }
}

In this example, the nested query is used to search for ‘user’ objects where ‘first’ is ‘Alice’ and ‘last’ is ‘White’.

Optimizing Elasticsearch Nested Filter

The Nested Filter can be resource-intensive, here are some tips to optimize its performance:

1. Limit the Depth of Nested Objects: The deeper the nested objects, the more resources Elasticsearch needs to query them. Try to keep your nested objects as shallow as possible.

2. Use Nested Filter Sparingly: Nested filters can be expensive in terms of performance. Use them sparingly and only when necessary.

3. Avoid Large Nested Objects: Large nested objects can slow down query performance. Try to keep your nested objects small and concise.

4. Use the ‘ignore_unmapped’ Option: If a nested query is run on a field that is not nested, it can cause an error, especially when the query is run over several indices and the nested field might be missing in one of them. To avoid this, use the ‘ignore_unmapped’ option.

GET /my_index/_search
{
  "query": {
    "nested": {
      "path": "user",
      "ignore_unmapped": true, 
      "query": {
        "bool": {
          "must": [
            { "match": { "user.first": "Alice" }},
            { "match": { "user.last":  "White" }}
          ]
        }
      }
    }
  }
}

In this example, if ‘user’ is not a nested field, the query will not throw an error.