Parameter passing

    $e->search( size => 10 );
    $e->search({size => 10});

Path parameters

    $e->search( index => 'my_index', type => 'my_type' );

Alternatively, you can specify a "path" parameter directly:

    $e->search( path => '/my_index/my_type' );

Query-string parameters

    $e->search( size => 10 );

If you pass in a "\%params" hash, then it will be included in the query string parameters without any error checking. The following:

    $e->search( size => 10, params => { from => 5, size => 5 })

would result in this query string:

    ?from=5&size=10

Body parameter

    $e->search(
        body => {
            query => {...}
        }
    );

The body can also be a UTF8-decoded string, which will be converted into UTF-8 bytes and passed as is:

    $e->indices->analyze( body => "The quick brown fox");

Filter path parameter

    $e->search(
        query => {...},
        filter_paths => [ 'hits.total', 'hits.hits._source' ]
    );

This parameter was added in Elasticsearch 1.6.0.

Ignore parameter

    $e->indices->delete(
        index  => 'my_index',
        ignore => 404
    );

This is most useful for Missing errors, which are triggered by a 404 status code when some requested resource does not exist.

Multiple error codes can be specified with an array:

    $e->indices->delete(
        index  => 'my_index',
        ignore => [404,409]
    );

"bulk_helper_class"

"scroll_helper_class"

"info()"

    $info = $e->info

Returns information about the version of Elasticsearch that the responding node is running.

"ping()"

    $e->ping

Pings a node in the cluster and returns 1 if it receives a 200 response, otherwise it throws an error.

"indices()"

    $indices_client = $e->indices;

Returns an Search::Elasticsearch::Client::1_0::Direct::Indices object which can be used for managing indices, eg creating, deleting indices, managing mapping, index settings etc.

"cluster()"

    $cluster_client = $e->cluster;

Returns an Search::Elasticsearch::Client::1_0::Direct::Cluster object which can be used for managing the cluster, eg cluster-wide settings and cluster health.

"nodes()"

    $node_client = $e->nodes;

Returns an Search::Elasticsearch::Client::1_0::Direct::Nodes object which can be used to retrieve node info and stats.

"snapshot()"

    $snapshot_client = $e->snapshot;

Returns an Search::Elasticsearch::Client::1_0::Direct::Snapshot object which is used for managing backup repositories and creating and restoring snapshots.

"cat()"

    $cat_client = $e->cat;

Returns an Search::Elasticsearch::Client::1_0::Direct::Cat object which can be used to retrieve simple to read text info for debugging and monitoring an Elasticsearch cluster.

"index()"

    $response = $e->index(
        index   => 'index_name',        # required
        type    => 'type_name',         # required
        id      => 'doc_id',            # optional, otherwise auto-generated

        body    => { document }         # required
    );

The "index()" method is used to index a new document or to reindex an existing document.

Query string parameters: "consistency", "op_type", "parent", "refresh", "replication", "routing", "timeout", "timestamp", "ttl", "version", "version_type"

See the index docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/docs-index_.html> for more information.

"create()"

    $response = $e->create(
        index   => 'index_name',        # required
        type    => 'type_name',         # required
        id      => 'doc_id',            # optional, otherwise auto-generated

        body    => { document }         # required
    );

The "create()" method works exactly like the "index()" method, except that it will throw a "Conflict" error if a document with the same "index", "type" and "id" already exists.

Query string parameters: "consistency", "op_type", "parent", "refresh", "replication", "routing", "timeout", "timestamp", "ttl", "version", "version_type"

See the create docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/docs-create.html> for more information.

"get()"

    $response = $e->get(
        index   => 'index_name',        # required
        type    => 'type_name',         # required
        id      => 'doc_id',            # required
    );

The "get()" method will retrieve the document with the specified "index", "type" and "id", or will throw a "Missing" error.

Query string parameters: "_source", "_source_exclude", "_source_include", "fields", "parent", "preference", "realtime", "refresh", "routing", "version", "version_type"

See the get docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/docs-get.html> for more information.

"get_source()"

    $response = $e->get_source(
        index   => 'index_name',        # required
        type    => 'type_name',         # required
        id      => 'doc_id',            # required
    );

The "get_source()" method works just like the "get()" method except that it returns just the "_source" field (the value of the "body" parameter in the "index()" method) instead of returning the "_source" field plus the document metadata, ie the "_index", "_type" etc.

Query string parameters: "_source", "_source_exclude", "_source_include", "parent", "preference", "realtime", "refresh", "routing", "version", "version_type"

See the get_source docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/docs-get.html> for more information.

"exists()"

    $response = $e->exists(
        index   => 'index_name',        # required
        type    => 'type_name',         # required
        id      => 'doc_id',            # required
    );

The "exists()" method returns 1 if a document with the specified "index", "type" and "id" exists, or an empty string if it doesn't.

Query string parameters: "parent", "preference", "realtime", "refresh", "routing"

See the exists docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/docs-get.html> for more information.

"delete()"

    $response = $e->delete(
        index   => 'index_name',        # required
        type    => 'type_name',         # required
        id      => 'doc_id',            # required
    );

The "delete()" method will delete the document with the specified "index", "type" and "id", or will throw a "Missing" error.

Query string parameters: "consistency", "parent", "refresh", "replication", "routing", "timeout", "version", "version_type"

See the delete docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/docs-delete.html> for more information.

"update()"

    $response = $e->update(
        index   => 'index_name',        # required
        type    => 'type_name',         # required
        id      => 'doc_id',            # required

        body    => { update }           # required
    );

The "update()" method updates a document with the corresponding "index", "type" and "id" if it exists. Updates can be performed either by:

• providing a partial document to be merged in to the existing document:

      $response = $e->update(
          ...,
          body => {
              doc => { new_field => 'new_value'},
          }
      );
      

• or with a script:

      $response = $e->update(
          ...,
          body => {
              script => "ctx._source.counter += incr",
              params => { incr => 5 }
          }
      );
      

Query string parameters: "consistency", "fields", "lang", "parent", "realtime", "refresh", "replication", "retry_on_conflict", "routing", "script", "script_id", "scripted_upsert", "timeout", "timestamp", "ttl", "version", "version_type"

See the update docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/docs-update.html> for more information.

"termvectors()"

    $results = $e->termvectors(
        index   => $index,          # required
        type    => $type,           # required

        id      => $id,             # optional
        body    => {...}            # optional
    )

The "termvectors()" method retrieves term and field statistics, positions, offsets and payloads for the specified document, assuming that termvectors have been enabled.

Query string parameters: "dfs", "field_statistics", "fields", "offsets", "parent", "payloads", "positions", "preference", "realtime", "routing", "term_statistics", "version", "version_type"

See the termvector docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/docs-termvectors.html> for more information.

"bulk()"

    $response = $e->bulk(
        index   => 'index_name',        # required if type specified
        type    => 'type_name',         # optional

        body    => [ actions ]          # required
    );

See Search::Elasticsearch::Client::1_0::Bulk and "bulk_helper()" for a helper module that makes bulk indexing simpler to use.

The "bulk()" method can perform multiple "index()", "create()", "delete()" or "update()" actions with a single request. The "body" parameter expects an array containing the list of actions to perform.

An action consists of an initial metadata hash ref containing the action type, plus the associated metadata, eg :

    { delete => { _index => 'index', _type => 'type', _id => 123 }}

The "index" and "create" actions then expect a hashref containing the document itself:

    { create => { _index => 'index', _type => 'type', _id => 123 }},
    { title => "A newly created document" }

And the "update" action expects a hashref containing the update commands, eg:

    { update => { _index => 'index', _type => 'type', _id => 123 }},
    { script => "ctx._source.counter+=1" }

Each action can include the same parameters that you would pass to the equivalent "index()", "create()", "delete()" or "update()" request, except that "_index", "_type" and "_id" must be specified with the preceding underscore. All other parameters can be specified with or without the underscore.

For instance:

    $response = $e->bulk(
        index   => 'index_name',        # default index name
        type    => 'type_name',         # default type name
        body    => [

            # create action
            { create => {
                _index => 'not_the_default_index',
                _type  => 'not_the_default_type',
                _id    => 123
            }},
            { title => 'Foo' },

            # index action
            { index => { _id => 124 }},
            { title => 'Foo' },

            # delete action
            { delete => { _id => 125 }},

            # update action
            { update => { _id => 126 }},
            { script => "ctx._source.counter+1" }
        ]
    );

Each action is performed separately. One failed action will not cause the others to fail as well.

Query string parameters: "consistency", "refresh", "replication", "timeout"

See the bulk docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/docs-bulk.html> for more information.

"bulk_helper()"

    $bulk_helper = $e->bulk_helper( @args );

Returns a new instance of the class specified in the "bulk_helper_class", which defaults to Search::Elasticsearch::Client::1_0::Bulk.

"mget()"

    $results = $e->mget(
        index   => 'default_index',     # optional, required when type specified
        type    => 'default_type',      # optional

        body    => { docs or ids }      # required
    );

The "mget()" method will retrieve multiple documents with a single request. The "body" consists of an array of documents to retrieve:

    $results = $e->mget(
        index   => 'default_index',
        type    => 'default_type',
        body    => {
            docs => [
                { _id => 1},
                { _id => 2, _type => 'not_the_default_type' }
            ]
        }
    );

You can also pass any of the other parameters that the "get()" request accepts.

If you have specified an "index" and "type", you can just include the "ids" of the documents to retrieve:

    $results = $e->mget(
        index   => 'default_index',
        type    => 'default_type',
        body    => {
            ids => [ 1, 2, 3]
        }
    );

Query string parameters: "_source", "_source_exclude", "_source_include", "fields", "preference", "realtime", "refresh"

See the mget docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/docs-multi-get.html> for more information.

"delete_by_query()"

    $result = $e->delete_by_query(
        index => 'index' | \@indices,   # required
        type  => 'type'  | \@types,     # optional

        body  => { query }              # required

    );

The "delete_by_query()" method deletes all documents which match the query. For instance, to delete all documents from 2012:

    $result = $e->delete_by_query(
        body  => {
            query => {
                range => {
                    date => {
                        gte => '2012-01-01',
                        lt  => '2013-01-01'
                    }
                }
            }
        }
    );

Query string parameters: "allow_no_indices", "analyzer", "consistency", "default_operator", "df", "expand_wildcards", "ignore_unavailable", "q", "replication", "routing", "timeout"

See the delete_by_query docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/docs-delete-by-query.html> for more information.

"mtermvectors()"

    $results = $e->mtermvectors(
        index   => $index,          # required if type specified
        type    => $type,           # optional

        body    => { }              # optional
    )

Runs multiple "termvector()" requests in a single request, eg:

    $results = $e->mtermvectors(
        index   => 'test',
        body    => {
            docs => [
                { _type => 'test', _id => 1, fields => ['text'] },
                { _type => 'test', _id => 2, payloads => 1 },
            ]
        }
    );

Query string parameters: "field_statistics", "fields", "ids", "offsets", "parent", "payloads", "positions", "preference", "realtime", "routing", "term_statistics", "version", "version_type"

See the mtermvectors docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/docs-multi-termvectors.html> for more information.

"search()"

    $results = $e->search(
        index   => 'index' | \@indices,     # optional
        type    => 'type'  | \@types,       # optional

        body    => { search params }        # optional
    );

The "search()" method searches for matching documents in one or more indices. It is just as easy to search a single index as it is to search all the indices in your cluster. It can also return aggregations <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations.html> highlighted snippets <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-highlighting.html> and did-you-mean <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-suggesters-phrase.html> or search-as-you-type <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-suggesters-completion.html> suggestions.

The lite version of search <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-uri-request.html> allows you to specify a query string in the "q" parameter, using the Lucene query string syntax:

    $results = $e->search( q => 'title:(elasticsearch clients)');

However, the preferred way to search is by using the Query DSL <http://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html> to create a query, and passing that "query" in the request body <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-body.html>:

    $results = $e->search(
        body => {
            query => {
                match => { title => 'Elasticsearch clients'}
            }
        }
    );

Query string parameters: "_source", "_source_exclude", "_source_include", "allow_no_indices", "analyze_wildcard", "analyzer", "default_operator", "df", "expand_wildcards", "explain", "fielddata_fields", "fields", "from", "ignore_unavailable", "lenient", "lowercase_expanded_terms", "preference", "q", "query_cache", "routing", "scroll", "search_type", "size", "sort", "stats", "suggest_field", "suggest_mode", "suggest_size", "suggest_text", "terminate_after", "timeout", "track_scores", "version"

See the search reference <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-body.html> for more information.

Also see "send_get_body_as" in Search::Elasticsearch::Transport.

"search_exists()"

    $results = $e->search_exists(
        index   => 'index' | \@indices,     # optional
        type    => 'type'  | \@types,       # optional

        body    => { search params }        # optional
    );

Query string parameters: "allow_no_indices", "analyze_wildcard", "analyzer", "default_operator", "df", "expand_wildcards", "ignore_unavailable", "lenient", "lowercase_expanded_terms", "min_score", "preference", "q", "routing"

See the search exists reference <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-exists.html> for more information.

"count()"

    $results = $e->count(
        index   => 'index' | \@indices,     # optional
        type    => 'type'  | \@types,       # optional

        body    => { query }                # optional
    )

The "count()" method returns the total count of all documents matching the query:

    $results = $e->count(
        body => {
            query => {
                match => { title => 'Elasticsearch clients' }
            }
        }
    );

Query string parameters: "allow_no_indices", "analyze_wildcard", "analyzer", "default_operator", "df", "expand_wildcards", "ignore_unavailable", "lenient", "lowercase_expanded_terms", "min_score", "preference", "q", "routing"

See the count docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-count.html> for more information.

"search_template()"

    $results = $e->search_template(
        index   => 'index' | \@indices,     # optional
        type    => 'type'  | \@types,       # optional

        body    => { search params }        # optional
    );

Perform a search by specifying a template (either predefined or defined within the "body") and parameters to use with the template, eg:

    $results = $e->search_template(
        body => {
            template => {
                query => {
                    match => {
                        "{{my_field}}" => "{{my_value}}"
                    }
                },
                size => "{{my_size}}"
            },
            params => {
                my_field => 'foo',
                my_value => 'bar',
                my_size  => 5
            }
        }
    );

See the search template docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-template.html> for more information.

Query string parameters: "allow_no_indices", "expand_wildcards", "ignore_unavailable", "preference", "scroll", "search_type"

"scroll()"

    $results = $e->scroll(
        scroll      => '1m',
        scroll_id   => $id
    );

When a "search()" has been performed with the "scroll" parameter, the "scroll()" method allows you to keep pulling more results until the results are exhausted.

NOTE: you will almost always want to set the "search_type" to "scan" in your original "search()" request.

See "scroll_helper()" and Search::Elasticsearch::Scroll for a helper utility which makes managing scroll requests much easier.

Query string parameters: "scroll", "scroll_id"

See the scroll docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-scroll.html> and the search_type docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/search.html/search-request-search-type.html> for more information.

"clear_scroll()"

    $response = $e->clear_scroll(
        scroll_id => $id | \@ids    # required
    );

Or

    $response = $e->clear_scroll(
        body => $id
    );

The "clear_scroll()" method can clear unfinished scroll requests, freeing up resources on the server.

"scroll_helper()"

    $scroll_helper = $e->scroll_helper( @args );

Returns a new instance of the class specified in the "scroll_helper_class", which defaults to Search::Elasticsearch::Scroll.

"msearch()"

    $results = $e->msearch(
        index   => 'default_index' | \@indices,     # optional
        type    => 'default_type'  | \@types,       # optional

        body    => [ searches ]                     # required
    );

The "msearch()" method allows you to perform multiple searches in a single request. Similar to the "bulk()" request, each search request in the "body" consists of two hashes: the metadata hash then the search request hash (the same data that you'd specify in the "body" of a "search()" request). For instance:

    $results = $e->msearch(
        index   => 'default_index',
        type    => ['default_type_1', 'default_type_2'],
        body => [
            # uses defaults
            {},
            { query => { match_all => {} }},

            # uses a custom index
            { index => 'not_the_default_index' },
            { query => { match_all => {} }}
        ]
    );

Query string parameters: "search_type"

See the msearch docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-multi-search.html> for more information.

"explain()"

    $response = $e->explain(
        index   => 'my_index',  # required
        type    => 'my_type',   # required
        id      => 123,         # required

        body    => { search }   # required
    );

The "explain()" method explains why the specified document did or did not match a query, and how the relevance score was calculated. For instance:

    $response = $e->explain(
        index   => 'my_index',
        type    => 'my_type',
        id      => 123,
        body    => {
            query => {
                match => { title => 'Elasticsearch clients' }
            }
        }
    );

Query string parameters: "_source", "_source_exclude", "_source_include", "analyze_wildcard", "analyzer", "default_operator", "df", "fields", "lenient", "lowercase_expanded_terms", "parent", "preference", "q", "routing"

See the explain docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-explain.html> for more information.

"field_stats()"

    $response = $e->field_stats(
        index   => 'index'   | \@indices,   # optional
        fields  => 'field'   | \@fields,    # optional
        level   => 'cluster' | 'indices',   # optional
    );

The "field-stats" API returns statistical properties of a field (such as min and max values) without executing a search.

Query string parameters: "allow_no_indices", "expand_wildcards", "fields", "ignore_unavailable", "level"

See the field-stats docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-field-stats.html> for more information.

"search_shards()"

    $response = $e->search_shards(
        index   => 'index' | \@indices,     # optional
        type    => 'type'  | \@types,       # optional
    )

The "search_shards()" method returns information about which shards on which nodes will execute a search request.

Query string parameters: "allow_no_indices", "expand_wildcards", "ignore_unavailable", "local", "preference", "routing"

See the search-shards docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-shards.html> for more information.

"percolate()"

    $results = $e->percolate(
        index   => 'my_index',      # required
        type    => 'my_type',       # required

        body    => { percolation }  # required
    );

Percolation is search inverted: instead of finding docs which match a particular query, it finds queries which match a particular document, eg for alert-me-when functionality.

The "percolate()" method runs a percolation request to find the queries matching a particular document. In the "body" you should pass the "_source" field of the document under the "doc" key:

    $results = $e->percolate(
        index   => 'my_index',
        type    => 'my_type',
        body    => {
            doc => {
                title => 'Elasticsearch rocks'
            }
        }
    );

Query string parameters: "allow_no_indices", "expand_wildcards", "ignore_unavailable", "percolate_format", "percolate_index", "percolate_preference", "percolate_routing", "percolate_type", "preference", "routing", "version", "version_type"

See the percolate docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-percolate.html> for more information.

"count_percolate()"

    $results = $e->count_percolate(
        index   => 'my_index',      # required
        type    => 'my_type',       # required

        body    => { percolation }  # required
    );

The "count_percolate()" request works just like the "percolate()" request except that it returns a count of all matching queries, instead of the queries themselves.

    $results = $e->count_percolate(
        index   => 'my_index',
        type    => 'my_type',
        body    => {
            doc => {
                title => 'Elasticsearch rocks'
            }
        }
    );

Query string parameters: "allow_no_indices", "expand_wildcards", "ignore_unavailable", "percolate_index", "percolate_type", "preference", "routing", "version", "version_type"

See the percolate docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-percolate.html> for more information.

"mpercolate()"

    $results = $e->mpercolate(
        index   => 'my_index',               # required if type
        type    => 'my_type',                # optional

        body    => [ percolation requests ]  # required
    );

Multi-percolation allows multiple "percolate()" requests to be run in a single request.

    $results = $e->mpercolate(
        index   => 'my_index',
        type    => 'my_type',
        body    => [
            # first request
            { percolate => {
                index => 'twitter',
                type  => 'tweet'
            }},
            { doc => {message => 'some_text' }},

            # second request
            { percolate => {
                index => 'twitter',
                type  => 'tweet',
                id    => 1
            }},
            {},
        ]
    );

Query string parameters: "allow_no_indices", "expand_wildcards", "ignore_unavailable"

See the mpercolate docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-percolate.html> for more information.

"suggest()"

    $results = $e->suggest(
        index   => 'index' | \@indices,     # optional

        body    => { suggest request }      # required
    );

The "suggest()" method is used to run did-you-mean <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-suggesteres-phrase.html> or search-as-you-type <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-suggesters-completion.html> suggestion requests, which can also be run as part of a "search()" request.

    $results = $e->suggest(
        index   => 'my_index',
        body    => {
            my_suggestions => {
                phrase  => {
                    text    => 'johnny walker',
                    field   => 'title'
                }
            }
        }
    );

Query string parameters: "allow_no_indices", "expand_wildcards", "ignore_unavailable", "preference", "routing"

"mlt()"

    $results = $e->mlt(
        index   => 'my_index',  # required
        type    => 'my_type',   # required
        id      => 123,         # required

        body    => { search }   # optional
    );

The "mlt()" method runs a more-like-this query <http://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-mlt-query.html> to find other documents which are similar to the specified document.

Query string parameters: "boost_terms", "max_doc_freq", "max_query_terms", "max_word_length", "min_doc_freq", "min_term_freq", "min_word_length", "mlt_fields", "percent_terms_to_match", "routing", "search_from", "search_indices", "search_scroll", "search_size", "search_source", "search_type", "search_types", "stop_words"

See the mlt docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-more-like-this.html> for more information.

"put_script()"

    $result  = $e->put_script(
        lang => 'lang',     # required
        id   => 'id',       # required
        body => { script }  # required
    );

The "put_script()" method is used to store a script in the ".scripts" index. For instance:

    $result  = $e->put_scripts(
        lang => 'groovy',
        id   => 'hello_world',
        body => {
          script => q(return "hello world");
        }
    );

Query string parameters: "op_type", "version", "version_type"

See the indexed scripts docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/modules-scripting.html#_indexed_scripts> for more.

"get_script()"

    $script = $e->get_script(
        lang => 'lang',     # required
        id   => 'id',       # required
    );

Retrieve the indexed script from the ".scripts" index.

Query string parameters: "version", "version_type"

See the indexed scripts docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/modules-scripting.html#_indexed_scripts> for more.

"delete_script()"

    $script = $e->delete_script(
        lang => 'lang',     # required
        id   => 'id',       # required
    );

Delete the indexed script from the ".scripts" index.

Query string parameters: "version", "version_type"

See the indexed scripts docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/modules-scripting.html#_indexed_scripts> for more.

"put_template()"

    $result  = $e->put_template(
        id   => 'id',                       # required
        body => { template } || "template"  # required
    );

The "put_template()" method is used to store a template in the ".scripts" index. For instance:

    $result  = $e->put_template(
        id   => 'hello_world',
        body => {
          template => {
            query => {
              match => {
                title => "hello world"
              }
            }
          }
      }
    );

Query string parameters: None

See the indexed search template docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-template.html#_pre_registered_template> for more.

"get_template()"

    $script = $e->get_template(
        id   => 'id',       # required
    );

Retrieve the indexed template from the ".scripts" index.

Query string parameters: "version", "version_type"

See the indexed search template docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-template.html#_pre_registered_template> for more.

"delete_template()"

    $script = $e->delete_template(
        id   => 'id',       # required
    );

Delete the indexed template from the ".scripts" index.

Query string parameters: None

See the indexed search template docs <http://www.elastic.co/guide/en/elasticsearch/reference/current/search-template.html#_pre_registered_template> for more.