Object and nested types in Elasticsearch - Step-by-Step Execution

Concept Flow - Object and nested types

Define mapping with object type

↓

Store JSON document with nested objects

↓

Query on object fields

↓

Define mapping with nested type

↓

Store JSON document with nested arrays

↓

Query with nested query to match inner objects

↓

Return matching documents

This flow shows how Elasticsearch handles object and nested types: defining mappings, storing documents, and querying them differently.

Execution Sample

Elasticsearch

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

Defines an index with a nested type field called 'user' to store arrays of objects.

Execution Table

Step	Action	Input/Condition	Result/Output
1	Define mapping with object type	{"properties":{"address":{"type":"object"}}}	Mapping created with 'address' as object type
2	Index document with nested JSON	{"address":{"city":"NY","zip":"10001"}}	Document stored with 'address' object
3	Query on object field	Match 'address.city' = 'NY'	Document returned if city matches
4	Define mapping with nested type	{"properties":{"user":{"type":"nested"}}}	Mapping created with 'user' as nested type
5	Index document with nested array	{"user":[{"name":"Alice","age":30},{"name":"Bob","age":25}]}	Document stored with nested 'user' array
6	Query with nested query	Match 'user.name' = 'Alice' and 'user.age' = 30	Only documents with matching nested object returned
7	Query with simple object query	Match 'user.name' = 'Alice' and 'user.age' = 25	Document returned incorrectly because fields from different nested objects are mixed
8	Exit	No more queries	End of example

💡 Finished showing difference between object and nested types in mapping and querying

Variable Tracker

Variable	Start	After Step 2	After Step 5	Final
Mapping	Empty	{"address": object}	{"address": object, "user": nested}	{"address": object, "user": nested}
Document	None	{"address":{"city":"NY","zip":"10001"}}	{"address":{"city":"NY","zip":"10001"}, "user":[{"name":"Alice","age":30},{"name":"Bob","age":25}]}	Same
Query Result	None	Document returned if city matches	Document returned if nested user matches	Depends on query

Key Moments - 2 Insights

Why does a simple object query on nested fields sometimes return wrong results?

Because nested objects are stored separately, querying nested fields as simple objects can mix values from different nested objects, as shown in step 7 where the document is returned unexpectedly.

What is the main difference between object and nested types in Elasticsearch?

Object type stores JSON objects as a single document, while nested type stores each object in an array as a separate hidden document, enabling precise queries on inner objects (see steps 4-6).

Visual Quiz - 3 Questions

Look at the execution table, at which step is the nested type mapping defined?

A Step 2

B Step 4

C Step 6

D Step 1

💡 Hint

Check the 'Action' column for 'Define mapping with nested type' in the execution_table.

According to the variable tracker, what is the state of 'Document' after step 5?

A Document with address and nested user array

B Empty document

C Only address object stored

D Document with only nested user array

💡 Hint

Look at the 'Document' row under 'After Step 5' in variable_tracker.

If you query 'user.name' = 'Alice' and 'user.age' = 25 with nested type, what happens according to the execution table?

A No document is returned

B Query causes error

C Document is returned

D All documents are returned

💡 Hint

See step 7 in execution_table where simple object query on nested fields returns the document.

Concept Snapshot

Elasticsearch Object and Nested Types:
- Object type stores JSON objects as single documents.
- Nested type stores arrays of objects as separate hidden docs.
- Nested queries allow precise matching inside arrays.
- Use nested type for arrays of objects needing exact inner matches.
- Object type is simpler but can mix inner object fields in queries.

Full Transcript

This visual execution shows how Elasticsearch handles object and nested types. First, we define a mapping with an object type field and store a document with nested JSON. Queries on object fields return documents if the field matches. Then, we define a mapping with a nested type field to store arrays of objects. Documents with nested arrays are stored, and nested queries allow matching specific inner objects precisely. Simple queries on nested fields without nested query fail to match correctly because nested objects are stored separately. The variable tracker shows how mappings and documents evolve. Key moments clarify common confusions about querying nested fields and the difference between object and nested types. The quiz tests understanding of mapping steps, document states, and query results. This helps beginners see step-by-step how Elasticsearch manages complex JSON structures.

Practice

1. What is the main difference between object and nested types in Elasticsearch?

easy

A. Both types store data the same way but nested type is faster.

B. Object type stores arrays of objects separately, while nested type stores grouped fields as one JSON object.

C. Nested type is used only for numeric fields, object type for text fields.

D. Nested type stores arrays of objects separately to keep their fields linked during searches, while object type stores grouped fields as one JSON object.

Solution

1. Step 1: Understand object type storage

   Object type stores grouped fields as a single JSON object inside a document, meaning all fields are flattened and stored together.

2. Step 2: Understand nested type storage

   Nested type stores arrays of objects separately to maintain the relationship between fields within each object during searches.

3. Final Answer:

   Nested type stores arrays of objects separately to keep their fields linked during searches, while object type stores grouped fields as one JSON object. -> Option D

4. Quick Check:

   Nested keeps object fields linked = C [OK]

Hint: Nested keeps object arrays linked; object flattens fields [OK]

Common Mistakes:

• Confusing object and nested storage behavior
• Thinking nested is only for numeric fields
• Assuming both types store data the same way

2. Which of the following is the correct way to define a nested type field in an Elasticsearch mapping?

easy

A. "comments": { "type": "object" }

B. "comments": { "type": "keyword" }

C. "comments": { "type": "nested" }

D. "comments": { "type": "text" }

Solution

1. Step 1: Recall nested type syntax

   To define a nested field, the type must be explicitly set to "nested" in the mapping.

2. Step 2: Check options

   "comments": { "type": "nested" } correctly sets "comments" field type to "nested". Other options use incorrect types for nested data.

3. Final Answer:

   "comments": { "type": "nested" } -> Option C

4. Quick Check:

   Nested type requires "type": "nested" [OK]

Hint: Use "type": "nested" to define nested fields [OK]

Common Mistakes:

• Using "object" instead of "nested" for nested arrays
• Confusing text or keyword types with nested
• Omitting the type field

3. Given this mapping with a nested field comments and this document:

{"title": "Post", "comments": [{"user": "alice", "message": "Hi"}, {"user": "bob", "message": "Hello"}]}

Which query will correctly find documents where comments.user is "alice" and comments.message is "Hello" in the same comment object?

medium

A. { "query": { "nested": { "path": "comments", "query": { "bool": { "must": [ { "match": { "comments.user": "alice" } }, { "match": { "comments.message": "Hello" } } ] } } } } }

B. { "query": { "bool": { "must": [ { "match": { "comments.user": "alice" } }, { "match": { "comments.message": "Hello" } } ] } } }

C. { "query": { "term": { "comments.user": "alice" } } }

D. { "query": { "nested": { "path": "comments", "query": { "term": { "comments.message": "Hi" } } } } }

Solution

1. Step 1: Understand nested query usage

   To search inside nested fields and keep field relationships, use a nested query with the correct path and combined conditions inside it.

2. Step 2: Analyze options

   { "query": { "nested": { "path": "comments", "query": { "bool": { "must": [ { "match": { "comments.user": "alice" } }, { "match": { "comments.message": "Hello" } } ] } } } } } uses a nested query on "comments" with a bool must for both user "alice" and message "Hello" in the same nested object. { "query": { "bool": { "must": [ { "match": { "comments.user": "alice" } }, { "match": { "comments.message": "Hello" } } ] } } } searches flattened fields, losing the link. { "query": { "term": { "comments.user": "alice" } } } only matches user. { "query": { "nested": { "path": "comments", "query": { "term": { "comments.message": "Hi" } } } } } searches for message "Hi" only.

3. Final Answer:

   Uses nested query to match both conditions in the same nested object. -> Option A

4. Quick Check:

   Nested query with bool must inside = A [OK]

Hint: Use nested query with bool must for multiple nested conditions [OK]

Common Mistakes:

• Using bool query without nested for nested fields
• Searching fields separately losing object linkage
• Using term query without nested path

4. You wrote this mapping for a nested field:

{ "properties": { "tags": { "type": "nested", "properties": { "name": { "type": "keyword" } } } } }

But your nested query returns no results even though documents have matching tags. What is the likely mistake?

medium

A. You forgot to use a nested query; used a regular bool query instead.

B. You defined tags as object type instead of nested.

C. You used match query on keyword field instead of term query.

D. You indexed tags as text instead of keyword.

Solution

1. Step 1: Check mapping correctness

   The mapping correctly defines "tags" as nested with keyword "name" field, so mapping is fine.

2. Step 2: Identify query mistake

   If nested query returns no results, often the cause is using a regular bool query instead of a nested query to search nested fields, losing the link between nested objects.

3. Final Answer:

   You forgot to use a nested query; used a regular bool query instead. -> Option A

4. Quick Check:

   Nested fields require nested queries [OK]

Hint: Always use nested query for nested fields [OK]

Common Mistakes:

• Using bool query without nested for nested fields
• Confusing object and nested types in mapping
• Using match query on keyword fields

5. You have documents with a nested field orders containing product and quantity. You want to find documents where there is an order with product "apple" and quantity greater than 10, but also an order with product "banana" and quantity less than 5. Which query structure correctly finds such documents?

hard

A. { "query": { "nested": { "path": "orders", "query": { "bool": { "must": [ { "term": { "orders.product": "apple" } }, { "range": { "orders.quantity": { "gt": 10 } } }, { "term": { "orders.product": "banana" } }, { "range": { "orders.quantity": { "lt": 5 } } } ] } } } }

B. { "query": { "bool": { "must": [ { "nested": { "path": "orders", "query": { "bool": { "must": [ { "term": { "orders.product": "apple" } }, { "range": { "orders.quantity": { "gt": 10 } } } ] } } } }, { "nested": { "path": "orders", "query": { "bool": { "must": [ { "term": { "orders.product": "banana" } }, { "range": { "orders.quantity": { "lt": 5 } } } ] } } } } ] } } }

C. { "query": { "bool": { "must": [ { "term": { "orders.product": "apple" } }, { "range": { "orders.quantity": { "gt": 10 } } }, { "term": { "orders.product": "banana" } }, { "range": { "orders.quantity": { "lt": 5 } } } ] } } }

D. { "query": { "nested": { "path": "orders", "query": { "term": { "orders.product": "apple" } } } } }

Solution

1. Step 1: Understand nested query for multiple conditions

   Each nested object must be queried separately to keep conditions linked inside the same nested object.

2. Step 2: Analyze query options

   { "query": { "bool": { "must": [ { "nested": { "path": "orders", "query": { "bool": { "must": [ { "term": { "orders.product": "apple" } }, { "range": { "orders.quantity": { "gt": 10 } } } ] } } } }, { "nested": { "path": "orders", "query": { "bool": { "must": [ { "term": { "orders.product": "banana" } }, { "range": { "orders.quantity": { "lt": 5 } } } ] } } } } ] } } } uses two nested queries combined with bool must, one for "apple" orders with quantity > 10, another for "banana" orders with quantity < 5, correctly matching documents with both conditions in different nested objects.

3. Step 3: Identify incorrect options

   { "query": { "nested": { "path": "orders", "query": { "bool": { "must": [ { "term": { "orders.product": "apple" } }, { "range": { "orders.quantity": { "gt": 10 } } }, { "term": { "orders.product": "banana" } }, { "range": { "orders.quantity": { "lt": 5 } } } ] } } } } tries to combine all conditions in one nested query, which requires all conditions in the same nested object (impossible for different products). { "query": { "bool": { "must": [ { "term": { "orders.product": "apple" } }, { "range": { "orders.quantity": { "gt": 10 } } }, { "term": { "orders.product": "banana" } }, { "range": { "orders.quantity": { "lt": 5 } } } ] } } } ignores nested queries, losing object linkage. { "query": { "nested": { "path": "orders", "query": { "term": { "orders.product": "apple" } } } } } only queries for "apple" product.

4. Final Answer:

   Uses separate nested queries for each product condition. -> Option B

5. Quick Check:

   Separate nested queries for each condition = A [OK]

Hint: Use separate nested queries for different nested object conditions [OK]

Common Mistakes:

• Combining multiple product conditions in one nested query
• Not using nested queries for nested fields
• Assuming all conditions apply to the same nested object