File Coverage

blib/lib/Search/Elasticsearch/Client/8_0/Direct.pm

Criterion	Covered	Total	%
statement	9	64	14.0
branch			n/a
condition	0	12	0.0
subroutine	3	50	6.0
pod	2	2	100.0
total	14	128	10.9

# Licensed to Elasticsearch B.V under one or more agreements.
# Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
# See the LICENSE file in the project root for more information

package Search::Elasticsearch::Client::8_0::Direct;
$Search::Elasticsearch::Client::8_0::Direct::VERSION = '8.12';
use Moo;
with 'Search::Elasticsearch::Client::8_0::Role::API';
with 'Search::Elasticsearch::Role::Client::Direct';

use Search::Elasticsearch::Util qw(parse_params is_compat);
use namespace::clean;

sub _namespace {__PACKAGE__}

has 'async_search'         => ( is => 'lazy', init_arg => undef );
has 'autoscaling'          => ( is => 'lazy', init_arg => undef );
has 'cat'                  => ( is => 'lazy', init_arg => undef );
has 'ccr'                  => ( is => 'lazy', init_arg => undef );
has 'cluster'              => ( is => 'lazy', init_arg => undef );
has 'connector'            => ( is => 'lazy', init_arg => undef );
has 'connector_sync_job'   => ( is => 'lazy', init_arg => undef );
has 'dangling_indices'     => ( is => 'lazy', init_arg => undef );
has 'enrich'               => ( is => 'lazy', init_arg => undef );
has 'eql'                  => ( is => 'lazy', init_arg => undef );
has 'esql'                 => ( is => 'lazy', init_arg => undef );
has 'features'             => ( is => 'lazy', init_arg => undef );
has 'fleet'                => ( is => 'lazy', init_arg => undef );
has 'graph'                => ( is => 'lazy', init_arg => undef );
has 'ilm'                  => ( is => 'lazy', init_arg => undef );
has 'indices'              => ( is => 'lazy', init_arg => undef );
has 'inference'            => ( is => 'lazy', init_arg => undef );
has 'ingest'               => ( is => 'lazy', init_arg => undef );
has 'license'              => ( is => 'lazy', init_arg => undef );
has 'logstash'             => ( is => 'lazy', init_arg => undef );
has 'migration'            => ( is => 'lazy', init_arg => undef );
has 'ml'                   => ( is => 'lazy', init_arg => undef );
has 'monitoring'           => ( is => 'lazy', init_arg => undef );
has 'nodes'                => ( is => 'lazy', init_arg => undef );
has 'profiling'            => ( is => 'lazy', init_arg => undef );
has 'query_ruleset'        => ( is => 'lazy', init_arg => undef );
has 'rollup'               => ( is => 'lazy', init_arg => undef );
has 'searchable_snapshots' => ( is => 'lazy', init_arg => undef );
has 'search_application'   => ( is => 'lazy', init_arg => undef );
has 'security'             => ( is => 'lazy', init_arg => undef );
has 'shutdown'             => ( is => 'lazy', init_arg => undef );
has 'simulate'             => ( is => 'lazy', init_arg => undef );
has 'snapshot'             => ( is => 'lazy', init_arg => undef );
has 'slm'                  => ( is => 'lazy', init_arg => undef );
has 'sql'                  => ( is => 'lazy', init_arg => undef );
has 'ssl'                  => ( is => 'lazy', init_arg => undef );
has 'synonyms'             => ( is => 'lazy', init_arg => undef );
has 'tasks'                => ( is => 'lazy', init_arg => undef );
has 'text_structure'       => ( is => 'lazy', init_arg => undef );
has 'transform'            => ( is => 'lazy', init_arg => undef );
has 'watcher'              => ( is => 'lazy', init_arg => undef );
has 'xpack'                => ( is => 'lazy', init_arg => undef );
has 'bulk_helper_class'    => ( is => 'rw' );
has 'scroll_helper_class'  => ( is => 'rw' );
has '_bulk_class'          => ( is => 'lazy' );
has '_scroll_class'        => ( is => 'lazy' );

#===================================
sub _build__bulk_class {
#===================================
    my $self       = shift;
    my $bulk_class = $self->bulk_helper_class
        || 'Client::' . $self->api_version . '::Bulk';
    $self->_build_helper( 'bulk', $bulk_class );
}

#===================================
sub _build__scroll_class {
#===================================
    my $self         = shift;
    my $scroll_class = $self->scroll_helper_class
        || 'Client::' . $self->api_version . '::Scroll';
    $self->_build_helper( 'scroll', $scroll_class );
}

#===================================
sub bulk_helper {
#===================================
    my ( $self, $params ) = parse_params(@_);
    $params->{es} ||= $self;
    $self->_bulk_class->new($params);
}

#===================================
sub scroll_helper {
#===================================
    my ( $self, $params ) = parse_params(@_);
    $params->{es} ||= $self;
    $self->_scroll_class->new($params);
}

#===================================
sub _build_autoscaling          { shift->_build_namespace('Autoscaling') }
sub _build_async_search         { shift->_build_namespace('AsyncSearch') }
sub _build_cat                  { shift->_build_namespace('Cat') }
sub _build_ccr                  { shift->_build_namespace('CCR') }
sub _build_cluster              { shift->_build_namespace('Cluster') }
sub _build_connector            { shift->_build_namespace('Connector') }
sub _build_connector_sync_job   { shift->_build_namespace('ConnectorSyncJob') }
sub _build_dangling_indices     { shift->_build_namespace('DanglingIndices') }
sub _build_enrich               { shift->_build_namespace('Enrich') }
sub _build_eql                  { shift->_build_namespace('Eql') }
sub _build_esql                 { shift->_build_namespace('Esql') }
sub _build_features             { shift->_build_namespace('Features') }
sub _build_fleet                { shift->_build_namespace('Fleet') }
sub _build_graph                { shift->_build_namespace('Graph') }
sub _build_ilm                  { shift->_build_namespace('ILM') }
sub _build_indices              { shift->_build_namespace('Indices') }
sub _build_inference            { shift->_build_namespace('Inference') }
sub _build_ingest               { shift->_build_namespace('Ingest') }
sub _build_license              { shift->_build_namespace('License') }
sub _build_logstash             { shift->_build_namespace('Logstash') }
sub _build_migration            { shift->_build_namespace('Migration') }
sub _build_ml                   { shift->_build_namespace('ML') }
sub _build_monitoring           { shift->_build_namespace('Monitoring') }
sub _build_nodes                { shift->_build_namespace('Nodes') }
sub _build_profiling            { shift->_build_namespace('Profiling') }
sub _build_query_ruleset        { shift->_build_namespace('QueryRuleset') }
sub _build_rollup               { shift->_build_namespace('Rollup') }
sub _build_searchable_snapshots { shift->_build_namespace('SearchableSnapshots') }
sub _build_search_application   { shift->_build_namespace('SearchApplication') }
sub _build_security             { shift->_build_namespace('Security') }
sub _build_shutdown             { shift->_build_namespace('Shutdown') }
sub _build_simulate             { shift->_build_namespace('Simulate') }
sub _build_snapshot             { shift->_build_namespace('Snapshot') }
sub _build_slm                  { shift->_build_namespace('Slm') }
sub _build_sql                  { shift->_build_namespace('SQL') }
sub _build_ssl                  { shift->_build_namespace('SSL') }
sub _build_synonyms             { shift->_build_namespace('Synonyms') }
sub _build_tasks                { shift->_build_namespace('Tasks') }
sub _build_text_structure       { shift->_build_namespace('TextStructure') }
sub _build_transform            { shift->_build_namespace('Transform') }
sub _build_watcher              { shift->_build_namespace('Watcher') }
sub _build_xpack                { shift->_build_namespace('XPack') }
#===================================

__PACKAGE__->_install_api('');

1;

=pod

=encoding UTF-8

=head1 NAME

Search::Elasticsearch::Client::8_0::Direct - Thin client with full support for Elasticsearch 8.x APIs

=head1 VERSION

version 8.12

=head1 SYNOPSIS

Create a client:

    use Search::Elasticsearch;
    my $e = Search::Elasticsearch->new(
        client => '8_0::Direct'
    );

Index a doc:

    $e->index(
        index   => 'my_index',
        type    => 'blog_post',
        id      => 123,
        body    => {
            title   => "Elasticsearch clients",
            content => "Interesting content...",
            date    => "2013-09-23"
        }
    );

Get a doc:

    $e->get(
        index   => 'my_index',
        type    => 'my_type',
        id      => 123
    );

Search for docs:

    $results = $e->search(
        index   => 'my_index',
        body    => {
            query => {
                match => {
                    title => "elasticsearch"
                }
            }
        }
    );

Index-level requests:

    $e->indices->create( index => 'my_index' );
    $e->indices->delete( index => 'my_index' )

Ingest pipeline requests:

    $e->ingest->get_pipeline( id => 'apache-logs' );

Cluster-level requests:

    $health = $e->cluster->health;

Node-level requests:

    $info  = $e->nodes->info;
    $stats = $e->nodes->stats;

Snapshot and restore:

    $e->snapshot->create_repository(
        repository => 'my_backups',
        type       => 'fs',
        settings   => {
            location => '/mnt/backups'
        }
    );

    $e->snapshot->create(
        repository => 'my_backups',
        snapshot   => 'backup_2014'
    );

Task management:

    $e->tasks->list;

`cat` debugging:

    say $e->cat->allocation;
    say $e->cat->health;

Cross-cluster replication requests:

    say $e->ccr->follow;

Index lifecycle management requests:

    say $e->ilm->put_lifecycle;

=head1 DESCRIPTION

The L class provides the
Elasticsearch 8.x compatible client returned by:

    $e = Search::Elasticsearch->new(
        client => "8_0::Direct"  # default
    );

It is intended to be as close as possible to the native REST API that
Elasticsearch uses, so that it is easy to translate the
L
for an API to the equivalent in this client.

This class provides the methods for L,
L and L.
It also provides access to clients for managing L
and the L.

=head1 PREVIOUS VERSIONS OF ELASTICSEARCH

This version of the client supports the Elasticsearch 8.0 branch,
which is not backwards compatible with earlier branches.

If you need to talk to a version of Elasticsearch before 8.0.0, please
install one of the following modules:

=over

=item *

L

=item *

L

=item *

L

=item *

L

=item *

L

=item *

L

=back

=head1 CONVENTIONS

=head2 Parameter passing

Parameters can be passed to any request method as a list or as a hash
reference. The following two statements are equivalent:

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

=head2 Path parameters

Any values that should be included in the URL path, eg C
should be passed as top level parameters:

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

Alternatively, you can specify a C parameter directly:

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

=head2 Query-string parameters

Any values that should be included in the query string should be passed
as top level parameters:

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

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

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

would result in this query string:

    ?from=6&size=10

=head2 Body parameter

The request body should be passed in the C key:

    $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");

=head2 Boolean parameters

Elasticsearch 7.0.0 and above no longer accepts truthy and falsey values for booleans.  Instead,
it will accept only a JSON C or C, or the string equivalents C<"true"> or C<"false">.

In the Perl client, you can use the following values:

=over

=item * True: C, C<\1>, or a L object.

=item * False: C, C<\0>, or a L object.

=back

=head2 Filter path parameter

Any API which returns a JSON body accepts a C parameter
which will filter the JSON down to only the specified paths.  For instance,
if you are running a search request and only want the C hits and
the C<_source> field for each hit (without the C<_id>, C<_index> etc),
you can do:

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

=head2 Ignore parameter

Normally, any HTTP status code outside the 200-299 range will result in
an error being thrown.  To suppress these errors, you can specify which
status codes to ignore in the C parameter.

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

This is most useful for
L errors, which
are triggered by a C<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]
    );

=head1 CONFIGURATION

=head2 C

The class to use for the L method. Defaults to
L.

=head2 C

The class to use for the L method. Defaults to
L.

=head1 GENERAL METHODS

=head2 C

    $info = $e->info

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

=head2 C

    $e->ping

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

=head2 C

    $indices_client = $e->indices;

Returns a L object which can be used
for managing indices, eg creating, deleting indices, managing mapping,
index settings etc.

=head2 C

    $ingest_client = $e->ingest;

Returns a L object which can be used
for managing ingest pipelines.

=head2 C

    $cluster_client = $e->cluster;

Returns a L object which can be used
for managing the cluster, eg cluster-wide settings and cluster health.

=head2 C

    $node_client = $e->nodes;

Returns a L object which can be used
to retrieve node info and stats.

=head2 C

    $snapshot_client = $e->snapshot;

Returns a L object which
is used for managing backup repositories and creating and restoring
snapshots.

=head2 C

    $tasks_client = $e->tasks;

Returns a L object which
is used for accessing the task management API.

=head2 C

    $cat_client = $e->cat;

Returns a L object which can be used
to retrieve simple to read text info for debugging and monitoring an
Elasticsearch cluster.

=head2 C

    $ccr_client = $e->ccr;

Returns a L object which can be used
to handle cross-cluster replication requests.

=head2 C

    $ilm_client = $e->ilm;

Returns a L object which can be used
to handle index lifecycle management requests.

=head1 DOCUMENT CRUD METHODS

These methods allow you to perform create, index, update and delete requests
for single documents:

=head2 C

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

        body    => { document }         # required
    );

The C method is used to index a new document or to reindex
an existing document.

Query string parameters:
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

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

        body    => { document }         # required
    );

The C method works exactly like the L method, except
that it will throw a C error if a document with the same
C, C and C already exists.

Query string parameters:
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

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

The C method will retrieve the document with the specified
C, C and C, or will throw a C error.

Query string parameters:
    C<_source>,
    C<_source_excludes>,
    C<_source_includes>,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

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

The C method works just like the L method except that
it returns just the C<_source> field (the value of the C parameter
in the L method) instead of returning the C<_source> field
plus the document metadata, ie the C<_index>, C<_type> etc.

Query string parameters:
    C<_source>,
    C<_source_excludes>,
    C<_source_includes>,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

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

The C method returns C<1> if a document with the specified
C, C and C exists, or an empty string if it doesn't.

Query string parameters:
    C<_source>,
    C<_source_excludes>,
    C<_source_includes>,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

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

The C method will delete the document with the specified
C, C and C, or will throw a C error.

Query string parameters:
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

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

        body    => { update }           # required
    );

The C method updates a document with the corresponding
C, C and C if it exists. Updates can be performed either by:

=over

=item * providing a partial document to be merged in to the existing document:

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

=item * with an inline script:

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

=item * with an indexed script:

    $response = $e->update(
        ...,
        body => {
            script => {
                id     => $id,
                lang   => 'painless',
                params => { incr => 6 }
            }
        }
    );

See L
for more information.

=item * with a script stored as a file:

    $response = $e->update(
        ...,
        body => {
            script => {
                file   => 'counter',
                lang   => 'painless',
                params => { incr => 6 }
            }
        }
    );

See L
for more information.

=back

Query string parameters:
    C<_source>,
    C<_source_excludes>,
    C<_source_includes>,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

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

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

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

Query string parameters:
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head1 BULK DOCUMENT CRUD METHODS

The bulk document CRUD methods are used for running multiple CRUD actions
within a single request.  By reducing the number of network requests
that need to be made, bulk requests greatly improve performance.

=head2 C

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

        body    => [ actions ]          # required
    );

See L and L for a helper module that makes
bulk indexing simpler to use.

The C method can perform multiple L, L,
L or L actions with a single request. The C
parameter expects an array containing the list of actions to perform.

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

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

The C and C actions then expect a hashref containing
the document itself:

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

And the C 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 L, L, L or L
request, except that C<_index>, C<_type> and C<_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 => 126 }},

            # 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:
    C<_source>,
    C<_source_excludes>,
    C<_source_includes>,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

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

Returns a new instance of the class specified in the L,
which defaults to L.

=head2 C

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

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

The C method will retrieve multiple documents with a single request.
The C 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 L request
accepts.

If you have specified an C and C, you can just include the
C of the documents to retrieve:

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

Query string parameters:
    C<_source>,
    C<_source_excludes>,
    C<_source_includes>,
    C,
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

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

        body    => { }              # optional
    )

Runs multiple L 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:
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head1 SEARCH METHODS

The search methods are used for querying documents in one, more or all indices
and of one, more or all types:

=head2 C

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

        body    => { search params }        # optional
    );

The C 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
L
L
and L
or L
suggestions.

The I L
allows you to specify a query string in the C parameter, using the
Lucene query string syntax:

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

However, the preferred way to search is by using the
L
to create a query, and passing that C in the
L:

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

Query string parameters:
    C<_source>,
    C<_source_excludes>,
    C<_source_includes>,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

Also see L.

=head2 C

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

        body    => { query }                # optional
    )

The C method returns the total count of all documents matching the
query:

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

Query string parameters:
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

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

        body    => { search params }        # required
    );

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

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

See the L
for more information.

Query string parameters:
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C

=head2 C

    $response = $e->render_search_template(
        id   => 'id',           # optional
        body => { template }    # optional
    );

Renders the template, filling in the passed-in parameters and returns the resulting JSON, eg:

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

See the L
for more information.

=head2 C

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

When a L has been performed with the
C parameter, the C
method allows you to keep pulling more results until the results
are exhausted.

See L and L for a helper utility
which makes managing scroll requests much easier.

Query string parameters:
    C,
    C,
    C,
    C,
    C

See the L
and the L
for more information.

=head2 C

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

The C method can clear unfinished scroll requests, freeing
up resources on the server.

=head2 C

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

Returns a new instance of the class specified in the L,
which defaults to L.

=head2 C

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

        body    => [ searches ]                     # required
    );

The C method allows you to perform multiple searches in a single
request.  Similar to the L request, each search request in the
C consists of two hashes: the metadata hash then the search request
hash (the same data that you'd specify in the C of a L
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:
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

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

        body    => [ search_templates ]             # required
    );

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

    $results = $e->msearch(
        index   => 'default_index',
        type    => ['default_type_1', 'default_type_2'],
        body => [
            # uses defaults
            {},
            { source => { query => { match => { user => "{{user}}" }}} params => { user => 'joe' }},

            # uses a custom index
            { index => 'not_the_default_index' },
            { source => { query => { match => { user => "{{user}}" }}} params => { user => 'joe' }},
        ]
    );

Query string parameters:
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

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

        body    => { search }   # required
    );

The C 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:
    C<_source>,
    C<_source_excludes>,
    C<_source_includes>,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

    $response = $e->field_caps(
        index   => 'index'   | \@indices,   # optional
        body    => { filters }              # optional
    );

The C API returns field types and abilities, merged across indices.

Query string parameters:
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

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

The C method returns information about which shards on
which nodes will execute a search request.

Query string parameters:
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

    $result = $e->rank_eval(
        index   => 'index' | \@indices,     # optional
        body    => {...}                    # required
    );

The ranking evaluation API provides a way to execute test cases to determine whether search results
are improving or worsening.

Query string parameters:
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head1 CRUD-BY-QUERY METHODS

=head2 C

    $response = $e->delete_by_query(
        index   => 'index' | \@indices,     # optional
        type    => 'type'  | \@types,       # optional,
        body    => { delete-by-query }      # required
    );

The C method deletes all documents which match the specified query.

Query string parameters:
    C<_source>,
    C<_source_excludes>,
    C<_source_includes>,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

    $response = $e->delete_by_query_rethrottle(
        task_id             => 'id'         # required
        requests_per_second => num
    );

The C API is used to dynamically update the throtting
of an existing delete-by-query request, identified by C.

Query string parameters:
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

    $response = $e->reindex(
        body => { reindex }     # required
    );

The C API is used to index documents from one index or multiple indices
to a new index.

Query string parameters:
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

    $response = $e->delete_by_query_rethrottle(
        task_id => 'id',            # required
        requests_per_second => num
    );

The C API is used to dynamically update the throtting
of an existing reindex request, identified by C.

Query string parameters:
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

    $response = $e->update_by_query(
        index   => 'index' | \@indices,     # optional
        type    => 'type'  | \@types,       # optional,
        body    => { update-by-query }      # optional
    );

The C API is used to bulk update documents from one index or
multiple indices using a script.

Query string parameters:
    C<_source>,
    C<_source_excludes>,
    C<_source_includes>,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C,
    C

See the L
for more information.

=head2 C

    $response = $e->update_by_query_rethrottle(
        task_id             => 'id'         # required
        requests_per_second => num
    );

The C API is used to dynamically update the throtting
of an existing update-by-query request, identified by C.

Query string parameters:
    C,
    C,
    C,
    C

See the L
for more information.

=head1 INDEXED SCRIPT METHODS

Elasticsearch allows you to store scripts in the cluster state
and reference them by id. The methods to manage indexed scripts are as follows:

=head2 C

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

The C method is used to store a script in the cluster state. For instance:

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

Query string parameters:
    C,
    C

See the L for more.

=head2 C

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

Retrieve the indexed script from the cluster state.

Query string parameters:
    C,
    C,
    C

See the L for more.

=head2 C

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

Delete the indexed script from the cluster state.

Query string parameters:
    C,
    C,
    C,
    C

See the L for more.

=head2 C

    $result = $e->scripts_painless_execute(
        body => {...}   # required
    );

The Painless execute API allows an arbitrary script to be executed and a result to be returned.

Query string parameters:
    C,
    C,
    C

See the L for more.

=head1 AUTHOR

Enrico Zimuel

=head1 COPYRIGHT AND LICENSE

This software is Copyright (c) 2024 by Elasticsearch BV.

This is free software, licensed under:

  The Apache License, Version 2.0, January 2004

=cut

__END__