Search templates

Search templates

A search template is a stored search you can run with different variables.

If you use Elasticsearch as a search backend, you can pass user input from a search bar as parameters for a search template. This lets you run searches without exposing Elasticsearch’s query syntax to your users.

If you use Elasticsearch for a custom application, search templates let you change your searches without modifying your app’s code.

Create a search template

To create or update a search template, use the create stored script API.

The request’s source supports the same parameters as the search API‘s request body. source also supports Mustache variables, typically enclosed in double curly brackets: {{my-var}}. When you run a templated search, Elasticsearch replaces these variables with values from params.

Search templates must use a lang of mustache.

The following request creates a search template with an id of my-search-template.

  1. PUT _scripts/my-search-template
  2. {
  3.   "script": {
  4.     "lang": "mustache",
  5.     "source": {
  6.       "query": {
  7.         "match": {
  8.           "message": "{{query_string}}"
  9.         }
  10.       },
  11.       "from": "{{from}}",
  12.       "size": "{{size}}"
  13.     }
  14.   }
  15. }

Elasticsearch stores search templates as Mustache scripts in the cluster state. Elasticsearch compiles search templates in the template script context. Settings that limit or disable scripts also affect search templates.

Validate a search template

To test a template with different params, use the render search template API.

  1. POST _render/template
  2. {
  3.   "id": "my-search-template",
  4.   "params": {
  5.     "query_string": "hello world",
  6.     "from": 20,
  7.     "size": 10
  8.   }
  9. }

When rendered, the template outputs a search request body.

  1. {
  2.   "template_output": {
  3.     "query": {
  4.       "match": {
  5.         "message": "hello world"
  6.       }
  7.     },
  8.     "from": "20",
  9.     "size": "10"
  10.   }
  11. }

You can also use the API to test inline templates.

  1. POST _render/template
  2. {
  3.     "source": {
  4.       "query": {
  5.         "match": {
  6.           "message": "{{query_string}}"
  7.         }
  8.       },
  9.       "from": "{{from}}",
  10.       "size": "{{size}}"
  11.     },
  12.   "params": {
  13.     "query_string": "hello world",
  14.     "from": 20,
  15.     "size": 10
  16.   }
  17. }

To run a search with a search template, use the search template API. You can specify different params with each request.

  1. GET my-index/_search/template
  2. {
  3.   "id": "my-search-template",
  4.   "params": {
  5.     "query_string": "hello world",
  6.     "from": 0,
  7.     "size": 10
  8.   }
  9. }

The response uses the same properties as the search API‘s response.

  1. {
  2.   "took": 36,
  3.   "timed_out": false,
  4.   "_shards": {
  5.     "total": 1,
  6.     "successful": 1,
  7.     "skipped": 0,
  8.     "failed": 0
  9.   },
  10.   "hits": {
  11.     "total": {
  12.       "value": 1,
  13.       "relation": "eq"
  14.     },
  15.     "max_score": 0.5753642,
  16.     "hits": [
  17.       {
  18.         "_index": "my-index",
  19.         "_type": "_doc",
  20.         "_id": "1",
  21.         "_score": 0.5753642,
  22.         "_source": {
  23.           "message": "hello world"
  24.         }
  25.       }
  26.     ]
  27.   }
  28. }

Run multiple templated searches

To run multiple templated searches with a single request, use the multi search template API. These requests often have less overhead and faster speeds than multiple individual searches.

  1. GET my-index/_msearch/template
  2. { }
  3. { "id": "my-search-template", "params": { "query_string": "hello world", "from": 0, "size": 10 }}
  4. { }
  5. { "id": "my-other-search-template", "params": { "query_type": "match_all" }}

Get search templates

To retrieve a search template, use the get stored script API.

  1. GET _scripts/my-search-template

To get a list of all search templates and other stored scripts, use the cluster state API.

  1. GET _cluster/state/metadata?pretty&filter_path=metadata.stored_scripts

Delete a search template

To delete a search template, use the delete stored script API.

  1. DELETE _scripts/my-search-template

Set default values

To set a default value for a variable, use the following syntax:

  1. {{my-var}}{{^my-var}}default value{{/my-var}}

If a templated search doesn’t specify a value in its params, the search uses the default value instead. For example, the following template sets defaults for from and size.

  1. POST _render/template
  2. {
  3.   "source": {
  4.     "query": {
  5.       "match": {
  6.         "message": "{{query_string}}"
  7.       }
  8.     },
  9.     "from": "{{from}}{{^from}}0{{/from}}",
  10.     "size": "{{size}}{{^size}}10{{/size}}"
  11.   },
  12.   "params": {
  13.     "query_string": "hello world"
  14.   }
  15. }

URL encode strings

Use the {{#url}} function to URL encode a string.

  1. POST _render/template
  2. {
  3.   "source": {
  4.     "query": {
  5.       "term": {
  6.         "url.full": "{{#url}}{{host}}/{{page}}{{/url}}"
  7.       }
  8.     }
  9.   },
  10.   "params": {
  11.     "host": "http://example.com",
  12.     "page": "hello-world"
  13.   }
  14. }

The template renders as:

  1. {
  2.   "template_output": {
  3.     "query": {
  4.       "term": {
  5.         "url.full": "http%3A%2F%2Fexample.com%2Fhello-world"
  6.       }
  7.     }
  8.   }
  9. }

Concatenate values

Use the {{#join}} function to concatenate array values as a comma-delimited string. For example, the following template concatenates two email addresses.

  1. POST _render/template
  2. {
  3.   "source": {
  4.     "query": {
  5.       "match": {
  6.         "user.group.emails": "{{#join}}emails{{/join}}"
  7.       }
  8.     }
  9.   },
  10.   "params": {
  11.     "emails": [ "user1@example.com", "user_one@example.com" ]
  12.   }
  13. }

The template renders as:

  1. {
  2.   "template_output": {
  3.     "query": {
  4.       "match": {
  5.         "user.group.emails": "user1@example.com,user_one@example.com"
  6.       }
  7.     }
  8.   }
  9. }

You can also specify a custom delimiter.

  1. POST _render/template
  2. {
  3.   "source": {
  4.     "query": {
  5.       "range": {
  6.         "user.effective.date": {
  7.           "gte": "{{date.min}}",
  8.           "lte": "{{date.max}}",
  9.           "format": "{{#join delimiter='||'}}date.formats{{/join delimiter='||'}}"
  10.           }
  11.       }
  12.     }
  13.   },
  14.   "params": {
  15.     "date": {
  16.       "min": "2098",
  17.       "max": "06/05/2099",
  18.       "formats": ["dd/MM/yyyy", "yyyy"]
  19.     }
  20.   }
  21. }

The template renders as:

  1. {
  2.   "template_output": {
  3.     "query": {
  4.       "range": {
  5.         "user.effective.date": {
  6.           "gte": "2098",
  7.           "lte": "06/05/2099",
  8.           "format": "dd/MM/yyyy||yyyy"
  9.         }
  10.       }
  11.     }
  12.   }
  13. }

Convert to JSON

Use the {{#toJson}} function to convert a variable value to its JSON representation.

For example, the following template uses {{#toJson}} to pass an array. To ensure the request body is valid JSON, the source is written in the string format.

  1. POST _render/template
  2. {
  3.   "source": "{ \"query\": { \"terms\": { \"tags\": {{#toJson}}tags{{/toJson}} }}}",
  4.   "params": {
  5.     "tags": [
  6.       "prod",
  7.       "es01"
  8.     ]
  9.   }
  10. }

The template renders as:

  1. {
  2.   "template_output": {
  3.     "query": {
  4.       "terms": {
  5.         "tags": [
  6.           "prod",
  7.           "es01"
  8.         ]
  9.       }
  10.     }
  11.   }
  12. }

You can also use {{#toJson}} to pass objects.

  1. POST _render/template
  2. {
  3.   "source": "{ \"query\": {{#toJson}}my_query{{/toJson}} }",
  4.   "params": {
  5.     "my_query": {
  6.       "match_all": { }
  7.     }
  8.   }
  9. }

The template renders as:

  1. {
  2.   "template_output" : {
  3.     "query" : {
  4.       "match_all" : { }
  5.     }
  6.   }
  7. }

You can also pass an array of objects.

  1. POST _render/template
  2. {
  3.   "source": "{ \"query\": { \"bool\": { \"must\": {{#toJson}}clauses{{/toJson}} }}}",
  4.   "params": {
  5.     "clauses": [
  6.       {
  7.         "term": {
  8.           "user.id": "kimchy"
  9.         }
  10.       },
  11.       {
  12.         "term": {
  13.           "url.domain": "example.com"
  14.         }
  15.       }
  16.     ]
  17.   }
  18. }

The template renders as:

  1. {
  2.   "template_output": {
  3.     "query": {
  4.       "bool": {
  5.         "must": [
  6.           {
  7.             "term": {
  8.               "user.id": "kimchy"
  9.             }
  10.           },
  11.           {
  12.             "term": {
  13.               "url.domain": "example.com"
  14.             }
  15.           }
  16.         ]
  17.       }
  18.     }
  19.   }
  20. }

Use conditions

To create if conditions, use the following syntax:

  1. {{#condition}}content{{/condition}}

If the condition variable is true, Elasticsearch displays its content. For example, the following template searches data from the past year if year_scope is true.

  1. POST _render/template
  2. {
  3.   "source": "{ \"query\": { \"bool\": { \"filter\": [ {{#year_scope}} { \"range\": { \"@timestamp\": { \"gte\": \"now-1y/d\", \"lt\": \"now/d\" } } }, {{/year_scope}} { \"term\": { \"user.id\": \"{{user_id}}\" }}]}}}",
  4.   "params": {
  5.     "year_scope": true,
  6.     "user_id": "kimchy"
  7.   }
  8. }

The template renders as:

  1. {
  2.   "template_output" : {
  3.     "query" : {
  4.       "bool" : {
  5.         "filter" : [
  6.           {
  7.             "range" : {
  8.               "@timestamp" : {
  9.                 "gte" : "now-1y/d",
  10.                 "lt" : "now/d"
  11.               }
  12.             }
  13.           },
  14.           {
  15.             "term" : {
  16.               "user.id" : "kimchy"
  17.             }
  18.           }
  19.         ]
  20.       }
  21.     }
  22.   }
  23. }

If year_scope is false, the template searches data from any time period.

  1. POST _render/template
  2. {
  3.   "source": "{ \"query\": { \"bool\": { \"filter\": [ {{#year_scope}} { \"range\": { \"@timestamp\": { \"gte\": \"now-1y/d\", \"lt\": \"now/d\" } } }, {{/year_scope}} { \"term\": { \"user.id\": \"{{user_id}}\" }}]}}}",
  4.   "params": {
  5.     "year_scope": false,
  6.     "user_id": "kimchy"
  7.   }
  8. }

The template renders as:

  1. {
  2.   "template_output" : {
  3.     "query" : {
  4.       "bool" : {
  5.         "filter" : [
  6.           {
  7.             "term" : {
  8.               "user.id" : "kimchy"
  9.             }
  10.           }
  11.         ]
  12.       }
  13.     }
  14.   }
  15. }

To create if-else conditions, use the following syntax:

  1. {{#condition}}if content{{/condition}} {{^condition}}else content{{/condition}}

For example, the following template searches data from the past year if year_scope is true. Otherwise, it searches data from the past day.

  1. POST _render/template
  2. {
  3.   "source": "{ \"query\": { \"bool\": { \"filter\": [ { \"range\": { \"@timestamp\": { \"gte\": {{#year_scope}} \"now-1y/d\" {{/year_scope}} {{^year_scope}} \"now-1d/d\" {{/year_scope}} , \"lt\": \"now/d\" }}}, { \"term\": { \"user.id\": \"{{user_id}}\" }}]}}}",
  4.   "params": {
  5.     "year_scope": true,
  6.     "user_id": "kimchy"
  7.   }
  8. }