Nested objects and parent-child relationships in Elasticsearch are advanced features that enable us to model complex data structures and relationships within our indices. By understanding and using these features, we can improve the organization of our data and enhance the efficiency of our queries.

In this article, we will explore these concepts in detail Nested Objects, Parent-Child Relationships also Querying Nested Objects and Parent-Child Relationships in a beginner-friendly manner.

Nested Objects in Elasticsearch

Nested objects in Elasticsearch allow us to index arrays of objects as a single field, which is useful when dealing with arrays of objects that need to be queried or filtered as a single entity. Here’s how nested objects work:

• Indexing Nested Objects: When we index a document with a nested object, Elasticsearch indexes each object in the array as a separate hidden document, but maintains the relationship between the objects.
• Querying Nested Objects: To query nested objects we need to use a nested query, which allows us to query the nested objects as if they were indexed as separate documents.
• Mapping for Nested Objects: To use nested objects we need to define a mapping for the field as type “nested“. This tells Elasticsearch to treat the field as a nested object.

Example: Using Nested Objects

Suppose we have an index for storing blog posts and each post can have multiple comments. We can use a nested object to represent the comments within each post.

PUT /blog-posts
{
  "mappings": {
    "properties": {
      "title": { "type": "text" },
      "content": { "type": "text" },
      "comments": {
        "type": "nested",
        "properties": {
          "username": { "type": "keyword" },
          "comment": { "type": "text" },
          "created_at": { "type": "date" }
        }
      }
    }
  }
}

Explanation:

• We define a comments field as a nested object within the blog-posts index.
• Each comment has properties like username, comment, and created_at.
• By using a nested object, we can query and aggregate comments independently of each other.

Parent-Child Relationships in Elasticsearch

• Parent-child relationships allow us to establish connections between documents in different indices. This is useful for modeling data where there is a one-to-many or many-to-many relationship between entities.
• With parent-child relationships, we can maintain data separation while still being able to perform queries and aggregations across related documents.

Example: Using Parent-Child Relationships

Let’s consider a scenario where we have two indices: orders and order-items. Each order can have multiple items associated with it. We can use a parent-child relationship to model this relationship.

PUT /orders
{
  "mappings": {
    "properties": {
      "order_id": { "type": "keyword" },
      "customer_name": { "type": "text" }
    }
  }
}
,
PUT /order-items
{
  "mappings": {
    "_parent": {
      "type": "orders"
    },
    "properties": {
      "product_name": { "type": "text" },
      "quantity": { "type": "integer" },
      "price": { "type": "float" }
    }
  }
}

Explanation:

• We define the order–items index with a parent-child relationship to the orders index.
• Each document in the order-items index has a parent document in the orders index.
• This allows us to maintain the relationship between orders and their items while keeping them in separate indices.

Querying Nested Objects and Parent-Child Relationships

Both nested objects and parent-child relationships support querying and aggregations across related documents.

Example: Querying Nested Objects

Let’s Develop a search query for the Elasticsearch index “blog–posts” that retrieves all blog posts containing comments by a specific user, identified by the username “john_doe“.

GET /blog-posts/_search
{
  "query": {
    "nested": {
      "path": "comments",
      "query": {
        "match": {
          "comments.username": "john_doe"
        }
      }
    }
  }
}

Example: Querying Parent-Child Relationships

Let’s Create a search query for the Elasticsearch index “orders” to find all orders that contain a specific item, identified by the product name “Laptop” in the associated “order-items” child documents. Utilize the parent-child relationship to accurately query the “order-items” field within each order.

GET /orders/_search
{
  "query": {
    "has_child": {
      "type": "order-items",
      "query": {
        "match": {
          "product_name": "Laptop"
        }
      }
    }
  }
}

Conclusion

Nested objects and parent-child relationships are powerful features in Elasticsearch that allow for the modeling of complex data structures and relationships within indices.

By utilizing these features, developers can enhance the organization of their data and improve query efficiency. Understanding how to use nested objects and parent-child relationships, as well as how to query them, is essential for maximizing the capabilities of Elasticsearch in various use cases.