Dynamic templates in Elasticsearch - Mini Project: Build & Apply

Dynamic templates

📖 Scenario: You are setting up an Elasticsearch index to store product information. You want to automatically map fields that contain text to use a keyword type for exact matching, and fields that contain numbers to use a long type.

🎯 Goal: Create an Elasticsearch index with dynamic templates that automatically assign the keyword type to text fields and the long type to numeric fields.

📋 What You'll Learn

Create an index mapping with a dynamic_templates array

Add a dynamic template named strings_as_keywords that matches fields of type string and maps them as keyword

Add a dynamic template named numbers_as_long that matches fields of type long and maps them as long

Print the final mapping JSON

💡 Why This Matters

🌍 Real World

Dynamic templates are used in Elasticsearch to simplify index mappings by automatically assigning field types based on data patterns. This saves time and reduces errors when indexing diverse data.

💼 Career

Understanding dynamic templates is important for roles involving search engine setup, data indexing, and backend development where Elasticsearch is used to manage large datasets efficiently.

1

Create the initial index mapping with empty dynamic_templates

Create a variable called mapping and assign it a dictionary with a mappings key containing an empty dynamic_templates list.

Elasticsearch

mapping = {
    "mappings": {
        "dynamic_templates": []
    }
}
# Your code here

Hint

Use a dictionary with keys mappings and inside it dynamic_templates as an empty list.

2

Add a dynamic template for string fields as keyword

Add a dictionary to mapping["mappings"]["dynamic_templates"] with a template named strings_as_keywords that matches fields of type string and maps them as keyword type.

Elasticsearch

mapping = {
    "mappings": {
        "dynamic_templates": []
    }
}
# Add dynamic template for strings_as_keywords here

Hint

Use a dictionary with keys strings_as_keywords, match_mapping_type set to string, and mapping with type set to keyword.

3

Add a dynamic template for numeric fields as long

Add another dictionary to mapping["mappings"]["dynamic_templates"] with a template named numbers_as_long that matches fields of type long and maps them as long type.

Elasticsearch

mapping = {
    "mappings": {
        "dynamic_templates": [
            {
                "strings_as_keywords": {
                    "match_mapping_type": "string",
                    "mapping": {
                        "type": "keyword"
                    }
                }
            }
        ]
    }
}
# Add dynamic template for numbers_as_long here

Hint

Add a dictionary similar to the string template but with match_mapping_type as long and type as long.

4

Print the final mapping JSON

Use print(mapping) to display the final mapping dictionary.

Elasticsearch

mapping = {
    "mappings": {
        "dynamic_templates": [
            {
                "strings_as_keywords": {
                    "match_mapping_type": "string",
                    "mapping": {
                        "type": "keyword"
                    }
                }
            },
            {
                "numbers_as_long": {
                    "match_mapping_type": "long",
                    "mapping": {
                        "type": "long"
                    }
                }
            }
        ]
    }
}
# Print the mapping dictionary below

Hint

Use print(mapping) to show the dictionary.

Practice

1. What is the main purpose of dynamic_templates in Elasticsearch?

easy

A. To automatically map new fields based on user-defined rules

B. To manually define each field's mapping one by one

C. To delete old indexes automatically

D. To backup data to another cluster

Solution

1. Step 1: Understand dynamic templates concept

   Dynamic templates let Elasticsearch automatically apply mapping rules to new fields without manual intervention.

2. Step 2: Compare options with concept

   Only To automatically map new fields based on user-defined rules describes automatic mapping based on rules, which matches the purpose of dynamic templates.

3. Final Answer:

   To automatically map new fields based on user-defined rules -> Option A

4. Quick Check:

   Dynamic templates = automatic mapping rules [OK]

Hint: Dynamic templates automate field mapping using rules [OK]

Common Mistakes:

• Thinking dynamic templates delete or backup data
• Confusing manual mapping with dynamic templates
• Assuming dynamic templates only work for existing fields

2. Which of the following is the correct syntax to define a dynamic template that matches fields ending with _date and maps them as date type?

easy

A. "dynamic_templates": [{"dates": {"match": "*_date", "mapping": {"type": "date"}}}]

B. "dynamic_templates": [{"dates": {"match_pattern": "regex", "match": ".*_date$", "mapping": {"type": "date"}}}]

C. "dynamic_templates": [{"dates": {"match": "date", "mapping": {"type": "date"}}}]

D. "dynamic_templates": [{"dates": {"path_match": "*_date", "mapping": {"type": "date"}}}]

Solution

1. Step 1: Identify correct syntax for regex matching

   To match fields ending with '_date', we use match_pattern": "regex" and match": ".*_date$".

2. Step 2: Verify mapping type

   The mapping type should be date as required.

3. Final Answer:

   "dynamic_templates": [{"dates": {"match_pattern": "regex", "match": ".*_date$", "mapping": {"type": "date"}}}] -> Option B

4. Quick Check:

   Regex match + date type = "dynamic_templates": [{"dates": {"match_pattern": "regex", "match": ".*_date$", "mapping": {"type": "date"}}}] [OK]

Hint: Use match_pattern: regex for pattern matching [OK]

Common Mistakes:

• Using match without match_pattern for regex
• Using path_match instead of match for field names
• Incorrect regex syntax or missing $ anchor

3. Given this dynamic template snippet in Elasticsearch mapping:

{
  "dynamic_templates": [
    {
      "strings_as_keywords": {
        "match_mapping_type": "string",
        "mapping": {
          "type": "keyword"
        }
      }
    }
  ]
}

What will be the type of a newly indexed field named username with string value?

medium

A. "text"

B. "object"

C. "keyword"

D. "string"

Solution

1. Step 1: Analyze the dynamic template rule

   The template matches fields of type "string" and maps them as "keyword" type.

2. Step 2: Apply rule to field "username"

   Since "username" is a string field, it will be mapped as "keyword" according to the template.

3. Final Answer:

   "keyword" -> Option C

4. Quick Check:

   String fields mapped as keyword = "keyword" [OK]

Hint: match_mapping_type: string maps to keyword here [OK]

Common Mistakes:

• Assuming default type is text instead of keyword
• Confusing match and match_mapping_type
• Thinking string type is valid mapping in Elasticsearch 7+

4. You wrote this dynamic template but it does not apply to fields ending with _id. What is the error?

{
  "dynamic_templates": [
    {
      "ids": {
        "match": "*_id",
        "mapping": {
          "type": "keyword"
        }
      }
    }
  ]
}

medium

A. Incorrect mapping type, should be "text" instead of "keyword"

B. Dynamic templates must be outside the mappings block

C. Field name should be "path_match" not "match"

D. Missing "match_pattern": "regex" to enable wildcard matching

Solution

1. Step 1: Identify the matching issue

   The pattern "*_id" uses a wildcard, which requires "match_pattern": "regex" or "wildcard" to work properly.

2. Step 2: Confirm mapping and placement

   The mapping type "keyword" is correct for IDs, and dynamic templates are correctly placed inside mappings.

3. Final Answer:

   Missing "match_pattern": "regex" to enable wildcard matching -> Option D

4. Quick Check:

   Wildcard match needs match_pattern [OK]

Hint: Add match_pattern for wildcard or regex matches [OK]

Common Mistakes:

• Forgetting match_pattern with wildcards
• Changing mapping type unnecessarily
• Placing dynamic templates outside mappings

5. You want to create a dynamic template that maps all numeric fields with names containing _count as long type, but only if the field value is greater than zero. Which approach correctly applies this logic?

hard

A. Dynamic templates cannot filter by field value; use mapping for "long" and filter in queries

B. Use a dynamic template with match for "*_count" and mapping type "long"; add a runtime field to check > 0

C. Use a dynamic template with match for "*_count" and mapping type "long"; then filter documents with a query for values > 0

D. Use a dynamic template with match for "*_count" and mapping type "long" with a condition for > 0

Solution

1. Step 1: Understand dynamic templates capabilities

   Dynamic templates define field mappings based on name or type patterns, but cannot apply conditions based on field values.

2. Step 2: Identify correct approach for value filtering

   Filtering by field value (> 0) must be done at query time, not mapping time.

3. Final Answer:

   Dynamic templates cannot filter by field value; use mapping for "long" and filter in queries -> Option A

4. Quick Check:

   Value filtering = query, not mapping [OK]

Hint: Dynamic templates map fields; value filters happen in queries [OK]

Common Mistakes:

• Trying to filter field values in dynamic templates
• Adding unsupported 'condition' in mapping
• Confusing mapping with query filtering