Dynamic templates in Elasticsearch - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a dynamic template that matches all string fields.

Elasticsearch

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

Drag options to blanks, or click blank then click option'

Astring

Btext

Ckeyword

Ddate

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'text' instead of 'string' for match_mapping_type.

Using 'keyword' which is a field type, not a match_mapping_type.

The match_mapping_type for string fields is string in dynamic templates.

2fill in blank

medium

Complete the code to apply a dynamic template only to fields matching the pattern 'user_*'.

Elasticsearch

{
  "mappings": {
    "dynamic_templates": [
      {
        "user_fields": {
          "match": "[1]",
          "mapping": {
            "type": "text"
          }
        }
      }
    ]
  }
}

Drag options to blanks, or click blank then click option'

Auser

Buser.*

Cuser_*

Duser?

Attempts:

3 left

💡 Hint

Common Mistakes

Using '?' which matches a single character.

Using 'user' without wildcard, which matches only exact field name.

The match pattern uses wildcard syntax, so user_* matches all fields starting with 'user_'.

3fill in blank

hard

Fix the error in the dynamic template to set the type to 'date' for fields matching 'date_*'.

Elasticsearch

{
  "mappings": {
    "dynamic_templates": [
      {
        "dates": {
          "match": "date_*",
          "mapping": {
            "type": "[1]"
          }
        }
      }
    ]
  }
}

Drag options to blanks, or click blank then click option'

Adatetime

Btime

Ctimestamp

Ddate

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'datetime' or 'timestamp' which are not valid Elasticsearch types.

Using 'time' which is not a valid field type.

The correct Elasticsearch field type for dates is date.

4fill in blank

hard

Fill both blanks to create a dynamic template that maps all numeric fields to type 'long' and disables indexing.

Elasticsearch

{
  "mappings": {
    "dynamic_templates": [
      {
        "long_numbers": {
          "match_mapping_type": "[1]",
          "mapping": {
            "type": "[2]",
            "index": false
          }
        }
      }
    ]
  }
}

Drag options to blanks, or click blank then click option'

Along

Binteger

Dfloat

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'integer' or 'float' instead of 'long' for long numbers.

Forgetting to disable indexing.

The match_mapping_type for long numbers is long, and the field type should also be set to long.

5fill in blank

hard

Fill all three blanks to create a dynamic template that matches fields ending with '_txt', maps them as 'text' type with 'english' analyzer, and disables norms.

Elasticsearch

{
  "mappings": {
    "dynamic_templates": [
      {
        "text_fields": {
          "match": "[1]",
          "mapping": {
            "type": "[2]",
            "analyzer": "[3]",
            "norms": false
          }
        }
      }
    ]
  }
}

Drag options to blanks, or click blank then click option'

A*_txt

Btext

Cenglish

Dkeyword

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'keyword' type instead of 'text'.

Using wrong match pattern without wildcard.

The match pattern *_txt matches fields ending with '_txt'. The type is text with the english analyzer and norms disabled.

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