Module: Elasticsearch::API::Indices::Actions

Included in:
IndicesClient
Defined in:
lib/elasticsearch/api/namespace/indices.rb,
lib/elasticsearch/api/actions/indices/get.rb,
lib/elasticsearch/api/actions/indices/open.rb,
lib/elasticsearch/api/actions/indices/seal.rb,
lib/elasticsearch/api/actions/indices/close.rb,
lib/elasticsearch/api/actions/indices/flush.rb,
lib/elasticsearch/api/actions/indices/split.rb,
lib/elasticsearch/api/actions/indices/stats.rb,
lib/elasticsearch/api/actions/indices/create.rb,
lib/elasticsearch/api/actions/indices/delete.rb,
lib/elasticsearch/api/actions/indices/exists.rb,
lib/elasticsearch/api/actions/indices/freeze.rb,
lib/elasticsearch/api/actions/indices/shrink.rb,
lib/elasticsearch/api/actions/indices/status.rb,
lib/elasticsearch/api/actions/indices/analyze.rb,
lib/elasticsearch/api/actions/indices/refresh.rb,
lib/elasticsearch/api/actions/indices/upgrade.rb,
lib/elasticsearch/api/actions/indices/optimize.rb,
lib/elasticsearch/api/actions/indices/recovery.rb,
lib/elasticsearch/api/actions/indices/rollover.rb,
lib/elasticsearch/api/actions/indices/segments.rb,
lib/elasticsearch/api/actions/indices/unfreeze.rb,
lib/elasticsearch/api/actions/indices/get_alias.rb,
lib/elasticsearch/api/actions/indices/put_alias.rb,
lib/elasticsearch/api/actions/indices/forcemerge.rb,
lib/elasticsearch/api/actions/indices/get_warmer.rb,
lib/elasticsearch/api/actions/indices/put_warmer.rb,
lib/elasticsearch/api/actions/indices/clear_cache.rb,
lib/elasticsearch/api/actions/indices/exists_type.rb,
lib/elasticsearch/api/actions/indices/get_aliases.rb,
lib/elasticsearch/api/actions/indices/get_mapping.rb,
lib/elasticsearch/api/actions/indices/put_mapping.rb,
lib/elasticsearch/api/actions/indices/delete_alias.rb,
lib/elasticsearch/api/actions/indices/exists_alias.rb,
lib/elasticsearch/api/actions/indices/flush_synced.rb,
lib/elasticsearch/api/actions/indices/get_settings.rb,
lib/elasticsearch/api/actions/indices/get_template.rb,
lib/elasticsearch/api/actions/indices/put_settings.rb,
lib/elasticsearch/api/actions/indices/put_template.rb,
lib/elasticsearch/api/actions/indices/shard_stores.rb,
lib/elasticsearch/api/actions/indices/delete_warmer.rb,
lib/elasticsearch/api/actions/indices/delete_mapping.rb,
lib/elasticsearch/api/actions/indices/snapshot_index.rb,
lib/elasticsearch/api/actions/indices/update_aliases.rb,
lib/elasticsearch/api/actions/indices/validate_query.rb,
lib/elasticsearch/api/actions/indices/delete_template.rb,
lib/elasticsearch/api/actions/indices/exists_template.rb,
lib/elasticsearch/api/actions/indices/params_registry.rb,
lib/elasticsearch/api/actions/indices/get_field_mapping.rb

Defined Under Namespace

Modules: ParamsRegistry

Instance Method Summary collapse

Instance Method Details

#analyze(arguments = {}) ⇒ Object

Note:

If your text for analysis is longer than 4096 bytes then you should use the :body argument, rather than :text, to avoid HTTP transport errors

Return the result of the analysis process (tokens)

Allows to “test-drive” the Elasticsearch analysis process by performing the analysis on the same text with different analyzers. An ad-hoc analysis chain can be built from specific tokenizer and filters.

client.indices.analyze body: { text: 'The Quick Brown Jumping Fox',

tokenizer: 'standard',
char_filter: ['html_strip'] }

Examples:

Analyze text “Quick Brown Jumping Fox” with the snowball analyzer


client.indices.analyze text: 'The Quick Brown Jumping Fox', analyzer: 'snowball'

Analyze text “Quick Brown Jumping Fox” with a custom tokenizer and filter chain


client.indices.analyze body: { text: 'The Quick Brown Jumping Fox',
                               tokenizer: 'whitespace',
                               filter: ['lowercase','stop'] }

Analyze text “Quick Brown Jumping Fox” with custom tokenizer, token and character filters

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (String)

    The name of the index to scope the operation

  • :body (String)

    The text on which the analysis should be performed

  • :analyzer (String)

    The name of the analyzer to use

  • :field (String)

    Use the analyzer configured for this field (instead of passing the analyzer name)

  • :filters (List)

    A comma-separated list of token filters to use for the analysis. (Also available as the `:token_filters` option)

  • :char_filters (List)

    A comma-separated list of char filters to use for the analysis

  • :explain (Boolean)

    Whether to output further details (default: false)

  • :attributes (List)

    A comma-separated list of token attributes to output (use with `:explain`)

  • :index (String)

    The name of the index to scope the operation

  • :prefer_local (Boolean)

    With `true`, specify that a local shard should be used if available, with `false`, use a random shard (default: true)

  • :text (String)

    The text on which the analysis should be performed (when request body is not used)

  • :tokenizer (String)

    The name of the tokenizer to use for the analysis

See Also:



49
50
51
52
53
54
55
56
57
58
59
# File 'lib/elasticsearch/api/actions/indices/analyze.rb', line 49

def analyze(arguments={})
  method = HTTP_GET
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_analyze'

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  params[:filters] = Utils.__listify(params[:filters]) if params[:filters]

  body   = arguments[:body]

  perform_request(method, path, params, body).body
end

#clear_cache(arguments = {}) ⇒ Object

Clear caches and other auxiliary data structures.

Can be performed against a specific index, or against all indices.

By default, all caches and data structures will be cleared. Pass a specific cache or structure name to clear just a single one.

Examples:

Clear all caches and data structures


client.indices.clear_cache

Clear the field data structure only


client.indices.clear_cache field_data: true

Clear only specific field in the field data structure


client.indices.clear_cache field_data: true, fields: 'created_at', filter_cache: false, id_cache: false

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index name to limit the operation

  • :field_data (Boolean)

    Clear field data

  • :fielddata (Boolean)

    Clear field data

  • :fields (List)

    A comma-separated list of fields to clear when using the `field_data` parameter (default: all)

  • :query (Boolean)

    Clear query caches

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing or closed)

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, none, all)

  • :index (List)

    A comma-separated list of index name to limit the operation

  • :recycler (Boolean)

    Clear the recycler cache

  • :request_cache (Boolean)

    Clear request cache

  • :request (Boolean)

    Clear request cache

See Also:



40
41
42
43
44
45
46
47
48
49
50
# File 'lib/elasticsearch/api/actions/indices/clear_cache.rb', line 40

def clear_cache(arguments={})
  method = HTTP_POST
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_cache/clear'

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = nil

  params[:fields] = Utils.__listify(params[:fields]) if params[:fields]

  perform_request(method, path, params, body).body
end

#close(arguments = {}) ⇒ Object

Close an index (keep the data on disk, but deny operations with the index).

A closed index can be opened again with the #close API.

Examples:

Close index named myindex


client.indices.close index: 'myindex'

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma separated list of indices to perform the operation on (Required)

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :ignore_indices (String)

    When performed on multiple indices, allows to ignore `missing` ones (options: none, missing) @until 1.0

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

  • :timeout (Time)

    Explicit operation timeout

Raises:

  • (ArgumentError)

See Also:



29
30
31
32
33
34
35
36
37
38
# File 'lib/elasticsearch/api/actions/indices/close.rb', line 29

def close(arguments={})
  raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
  method = HTTP_POST
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_close'

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = nil

  perform_request(method, path, params, body).body
end

#create(arguments = {}) ⇒ Object

Create an index.

Pass the index `settings` and `mappings` in the `:body` attribute.

Examples:

Create an index with specific settings, custom analyzers and mappings


client.indices.create index: 'test',
                      body: {
                        settings: {
                          index: {
                            number_of_shards: 1,
                            number_of_replicas: 0,
                            'routing.allocation.include.name' => 'node-1'
                          },
                          analysis: {
                            filter: {
                              ngram: {
                                type: 'nGram',
                                min_gram: 3,
                                max_gram: 25
                              }
                            },
                            analyzer: {
                              ngram: {
                                tokenizer: 'whitespace',
                                filter: ['lowercase', 'stop', 'ngram'],
                                type: 'custom'
                              },
                              ngram_search: {
                                tokenizer: 'whitespace',
                                filter: ['lowercase', 'stop'],
                                type: 'custom'
                              }
                            }
                          }
                        },
                        mappings: {
                          document: {
                            properties: {
                              title: {
                                type: 'multi_field',
                                fields: {
                                    title:  { type: 'string', analyzer: 'snowball' },
                                    exact:  { type: 'string', analyzer: 'keyword' },
                                    ngram:  { type: 'string',
                                              index_analyzer: 'ngram',
                                              search_analyzer: 'ngram_search'
                                    }
                                }
                              }
                            }
                          }
                        }
                      }

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (String)

    The name of the index (Required)

  • :body (Hash)

    Optional configuration for the index (`settings` and `mappings`)

  • :update_all_types (Boolean)

    Whether to update the mapping for all fields with the same name across all types

  • :wait_for_active_shards (Number)

    Wait until the specified number of shards is active

  • :timeout (Time)

    Explicit operation timeout

  • :master_timeout (Boolean)

    Timeout for connection to master

Raises:

  • (ArgumentError)

See Also:



71
72
73
74
75
76
77
78
79
80
# File 'lib/elasticsearch/api/actions/indices/create.rb', line 71

def create(arguments={})
  raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
  method = HTTP_PUT
  path   = Utils.__pathify Utils.__escape(arguments[:index])

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = arguments[:body]

  perform_request(method, path, params, body).body
end

#delete(arguments = {}) ⇒ Object

Delete an index, list of indices, or all indices in the cluster.

Examples:

Delete an index


client.indices.delete index: 'foo'

Delete a list of indices


client.indices.delete index: ['foo', 'bar']
client.indices.delete index: 'foo,bar'

Delete a list of indices matching wildcard expression


client.indices.delete index: 'foo*'

Delete all indices


client.indices.delete index: '_all'

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of indices to delete; use `_all` to delete all indices

  • :timeout (Time)

    Explicit operation timeout

  • :master_timeout (Time)

    Specify timeout for connection to master

  • :ignore_unavailable (Boolean)

    Ignore unavailable indexes (default: false)

  • :allow_no_indices (Boolean)

    Ignore if a wildcard expression resolves to no concrete indices (default: false)

  • :expand_wildcards (List)

    Whether wildcard expressions should get expanded to open or closed indices (options: open, closed, none, all) (default: open)

See Also:



36
37
38
39
40
41
42
43
44
45
46
47
48
# File 'lib/elasticsearch/api/actions/indices/delete.rb', line 36

def delete(arguments={})
  method = HTTP_DELETE
  path   = Utils.__pathify Utils.__listify(arguments[:index])

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = nil

  if Array(arguments[:ignore]).include?(404)
    Utils.__rescue_from_not_found { perform_request(method, path, params, body).body }
  else
    perform_request(method, path, params, body).body
  end
end

#delete_alias(arguments = {}) ⇒ Object

Delete a single index alias.

See the #update_aliases for performing operations with index aliases in bulk.

Examples:

Delete an alias


client.indices.delete_alias index: 'foo', name: 'bar'

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (String)

    The name of the index with an alias (Required)

  • :name (String)

    The name of the alias to be deleted (Required)

  • :timeout (Time)

    Explicit timestamp for the document

Raises:

  • (ArgumentError)

See Also:



20
21
22
23
24
25
26
27
28
29
30
# File 'lib/elasticsearch/api/actions/indices/delete_alias.rb', line 20

def delete_alias(arguments={})
  raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
  raise ArgumentError, "Required argument 'name' missing"  unless arguments[:name]
  method = HTTP_DELETE
  path   = Utils.__pathify Utils.__escape(arguments[:index]), '_alias', Utils.__escape(arguments[:name])

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = nil

  perform_request(method, path, params, body).body
end

#delete_mapping(arguments = {}) ⇒ Object

Delete all documents and mapping for a specific document type.

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names; use `_all` for all indices (Required)

  • :type (String)

    The name of the document type to delete (Required)

Raises:

  • (ArgumentError)

See Also:



13
14
15
16
17
18
19
20
21
22
# File 'lib/elasticsearch/api/actions/indices/delete_mapping.rb', line 13

def delete_mapping(arguments={})
  raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
  raise ArgumentError, "Required argument 'type' missing"  unless arguments[:type]
  method = HTTP_DELETE
  path   = Utils.__pathify Utils.__listify(arguments[:index]), Utils.__escape(arguments[:type])
  params = {}
  body   = nil

  perform_request(method, path, params, body).body
end

#delete_template(arguments = {}) ⇒ Object

Delete an index template.

Examples:

Delete a template named mytemplate


client.indices.delete_template name: 'mytemplate'

Delete all templates


client.indices.delete_template name: '*'

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :name (String)

    The name of the template (Required)

  • :timeout (Time)

    Explicit operation timeout

Raises:

  • (ArgumentError)

See Also:



21
22
23
24
25
26
27
28
29
30
31
32
33
34
# File 'lib/elasticsearch/api/actions/indices/delete_template.rb', line 21

def delete_template(arguments={})
  raise ArgumentError, "Required argument 'name' missing" unless arguments[:name]
  method = HTTP_DELETE
  path   = Utils.__pathify '_template', Utils.__escape(arguments[:name])

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body = nil

  if Array(arguments[:ignore]).include?(404)
    Utils.__rescue_from_not_found { perform_request(method, path, params, body).body }
  else
    perform_request(method, path, params, body).body
  end
end

#delete_warmer(arguments = {}) ⇒ Object

Delete one or more warmers for a list of indices.

Examples:

Delete a warmer named mywarmer for index named myindex


client.indices.delete_warmer index: 'myindex', name: 'mywarmer'

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names to register warmer for; use `_all` or empty string to perform the operation on all indices (Required)

  • :name (String)

    The name of the warmer (supports wildcards); leave empty to delete all warmers

  • :type (List)

    A comma-separated list of document types to register warmer for; use `_all` or empty string to perform the operation on all types

Raises:

  • (ArgumentError)

See Also:



20
21
22
23
24
25
26
27
28
# File 'lib/elasticsearch/api/actions/indices/delete_warmer.rb', line 20

def delete_warmer(arguments={})
  raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
  method = HTTP_DELETE
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_warmer', Utils.__listify(arguments[:name])
  params = {}
  body = nil

  perform_request(method, path, params, body).body
end

#exists(arguments = {}) ⇒ true, false Also known as: exists?

Return true if the index (or all indices in a list) exists, false otherwise.

Examples:

Check whether index named myindex exists


client.indices.exists? index: 'myindex'

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of indices to check (Required)

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :ignore_indices (String)

    When performed on multiple indices, allows to ignore `missing` ones (options: none, missing) @until 1.0

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

  • :local (Boolean)

    Return local information, do not retrieve the state from master node (default: false)

Returns:

  • (true, false)

Raises:

  • (ArgumentError)

See Also:



29
30
31
32
33
34
35
36
37
38
39
# File 'lib/elasticsearch/api/actions/indices/exists.rb', line 29

def exists(arguments={})
  raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
  method = HTTP_HEAD
  path   = Utils.__listify(arguments[:index])
  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = nil

  Utils.__rescue_from_not_found do
    perform_request(method, path, params, body).status == 200 ? true : false
  end
end

#exists_alias(arguments = {}) ⇒ Object Also known as: exists_alias?

Return true if the specified alias exists, false otherwise.

Examples:

Check whether index alias named myalias exists


client.indices.exists_alias? name: 'myalias'

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names to filter aliases

  • :name (List)

    A comma-separated list of alias names to return

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :ignore_indices (String)

    When performed on multiple indices, allows to ignore `missing` ones (options: none, missing) @until 1.0

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

  • :local (Boolean)

    Return local information, do not retrieve the state from master node (default: false)

See Also:



28
29
30
31
32
33
34
35
36
37
38
# File 'lib/elasticsearch/api/actions/indices/exists_alias.rb', line 28

def exists_alias(arguments={})
  method = HTTP_HEAD
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_alias', Utils.__escape(arguments[:name])

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body = nil

  Utils.__rescue_from_not_found do
    perform_request(method, path, params, body).status == 200 ? true : false
  end
end

#exists_template(arguments = {}) ⇒ Object Also known as: exists_template?

Return true if the specified index template exists, false otherwise.

client.indices.exists_template? name: 'mytemplate'

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :name (String)

    The name of the template (Required)

  • :local (Boolean)

    Return local information, do not retrieve the state from master node (default: false)

  • :master_timeout (Time)

    Explicit operation timeout for connection to master node

Raises:

  • (ArgumentError)

See Also:



16
17
18
19
20
21
22
23
24
25
26
27
# File 'lib/elasticsearch/api/actions/indices/exists_template.rb', line 16

def exists_template(arguments={})
  raise ArgumentError, "Required argument 'name' missing" unless arguments[:name]
  method = HTTP_HEAD
  path   = Utils.__pathify '_template', Utils.__escape(arguments[:name])

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body = nil

  Utils.__rescue_from_not_found do
    perform_request(method, path, params, body).status == 200 ? true : false
  end
end

#exists_type(arguments = {}) ⇒ Object Also known as: exists_type?

Return true if the specified type exists, false otherwise.

client.indices.exists_type? index: 'myindex', type: 'mytype'

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names; use `_all` to check the types across all indices (Required)

  • :type (List)

    A comma-separated list of document types to check (Required)

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :ignore_indices (String)

    When performed on multiple indices, allows to ignore `missing` ones (options: none, missing) @until 1.0

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

  • :local (Boolean)

    Return local information, do not retrieve the state from master node (default: false)

Raises:

  • (ArgumentError)

See Also:



27
28
29
30
31
32
33
34
35
36
37
38
39
# File 'lib/elasticsearch/api/actions/indices/exists_type.rb', line 27

def exists_type(arguments={})
  raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
  raise ArgumentError, "Required argument 'type' missing" unless arguments[:type]
  method = HTTP_HEAD
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_mapping', Utils.__escape(arguments[:type])

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body = nil

  Utils.__rescue_from_not_found do
    perform_request(method, path, params, body).status == 200 ? true : false
  end
end

#flush(arguments = {}) ⇒ Object

Note:

The flush operation is handled automatically by Elasticsearch, you don't need to perform it manually.

“Flush” the index or indices.

The “flush” operation clears the transaction log and memory and writes data to disk. It corresponds to a Lucene “commit” operation.

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names; use `_all` or empty string for all indices

  • :force (Boolean)

    Whether a flush should be forced even if it is not necessarily needed ie.

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

  • :wait_if_ongoing (Boolean)

    If set to true the flush operation will block until the flush can be executed if another flush operation is already executing. If set to false the flush will be skipped if another flush operation is already running. (Default: true)

See Also:



26
27
28
29
30
31
32
33
34
# File 'lib/elasticsearch/api/actions/indices/flush.rb', line 26

def flush(arguments={})
  method = HTTP_POST
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_flush'

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body = nil

  perform_request(method, path, params, body).body
end

#flush_synced(arguments = {}) ⇒ Object

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names; use `_all` or empty string for all indices

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing or closed)

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, none, all)

See Also:



13
14
15
16
17
18
19
20
21
22
23
24
25
# File 'lib/elasticsearch/api/actions/indices/flush_synced.rb', line 13

def flush_synced(arguments={})
  method = HTTP_POST
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_flush/synced'

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = nil

  if Array(arguments[:ignore]).include?(404)
    Utils.__rescue_from_not_found { perform_request(method, path, params, body).body }
  else
    perform_request(method, path, params, body).body
  end
end

#forcemerge(arguments = {}) ⇒ Object

Force merge an index, list of indices, or all indices in the cluster.

Examples:

Fully force merge an index


client.indices.forcemerge index: 'foo', max_num_segments: 1

Do not flush index after force-merging


client.indices.forcemerge index: 'foo', flush: false

Do not expunge deleted documents after force-merging


client.indices.forcemerge index: 'foo', only_expunge_deletes: false

Force merge a list of indices


client.indices.forcemerge index: ['foo', 'bar']
client.indices.forcemerge index: 'foo,bar'

forcemerge a list of indices matching wildcard expression


client.indices.forcemerge index: 'foo*'

forcemerge all indices


client.indices.forcemerge index: '_all'

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of indices to forcemerge; use `_all` to forcemerge all indices

  • :max_num_segments (Number)

    The number of segments the index should be merged into (default: dynamic)

  • :only_expunge_deletes (Boolean)

    Specify whether the operation should only expunge deleted documents

  • :flush (Boolean)

    Specify whether the index should be flushed after performing the operation (default: true)

See Also:



44
45
46
47
48
49
50
51
52
# File 'lib/elasticsearch/api/actions/indices/forcemerge.rb', line 44

def forcemerge(arguments={})
  method = HTTP_POST
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_forcemerge'

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body = nil

  perform_request(method, path, params, body).body
end

#freeze(arguments = {}) ⇒ Object

Note:

This feature is available in the Platinum distribution of Elasticsearch.

In order to keep indices available and queryable for a longer period but at the same time reduce their

hardware requirements they can be transitioned into a frozen state. Once an index is frozen, all of its
transient shard memory (aside from mappings and analyzers) is moved to persistent storage.

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma separated list of indices to freeze. (Required)

Raises:

  • (ArgumentError)

See Also:



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# File 'lib/elasticsearch/api/actions/indices/freeze.rb', line 16

def freeze(arguments = {})
  raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]

  valid_params = [
      :timeout,
      :master_timeout,
      :ignore_unavailable,
      :allow_no_indices,
      :expand_wildcards,
      :wait_for_active_shards]

  arguments = arguments.clone
  index = arguments.delete(:index)

  method = Elasticsearch::API::HTTP_POST
  path = Elasticsearch::API::Utils.__pathify Elasticsearch::API::Utils.__listify(index), '_freeze'
  params = Elasticsearch::API::Utils.__validate_and_extract_params arguments, valid_params

  perform_request(method, path, params).body
end

#get(arguments = {}) ⇒ Object

Retrieve information about one or more indices

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names (Required)

  • :feature (List)

    A comma-separated list of features (options: _settings, _mappings, _aliases]

  • :local (Boolean)

    Return local information, do not retrieve the state from master node (default: false)

  • :ignore_unavailable (Boolean)

    Ignore unavailable indexes (default: false)

  • :allow_no_indices (Boolean)

    Ignore if a wildcard expression resolves to no concrete indices (default: false)

  • :expand_wildcards (List)

    Whether wildcard expressions should get expanded to open or closed indices (default: open)

  • :flat_settings (Boolean)

    Return settings in flat format (default: false)

  • :human (Boolean)

    Whether to return version and creation date values in human-readable format (default: false)

  • :include_defaults (Boolean)

    Whether to return all default setting for each of the indices (default:false)

Raises:

  • (ArgumentError)

See Also:



26
27
28
29
30
31
32
33
34
35
36
# File 'lib/elasticsearch/api/actions/indices/get.rb', line 26

def get(arguments={})
  raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
  method = HTTP_GET

  path   = Utils.__pathify Utils.__listify(arguments[:index]), Utils.__listify(arguments.delete(:feature))

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body = nil

  perform_request(method, path, params, body).body
end

#get_alias(arguments = {}) ⇒ Object

Get information about a specific alias.

Examples:

Return all indices an alias points to


client.indices.get_alias name: '2013'

Return all indices matching a wildcard pattern an alias points to


client.indices.get_alias index: 'log*', name: '2013'

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names to filter aliases

  • :name (List)

    A comma-separated list of alias names to return

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :ignore_indices (String)

    When performed on multiple indices, allows to ignore `missing` ones (options: none, missing) @until 1.0

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

  • :local (Boolean)

    Return local information, do not retrieve the state from master node (default: false)

See Also:



32
33
34
35
36
37
38
39
40
# File 'lib/elasticsearch/api/actions/indices/get_alias.rb', line 32

def get_alias(arguments={})
  method = HTTP_GET
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_alias', Utils.__escape(arguments[:name])

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = nil

  perform_request(method, path, params, body).body
end

#get_aliases(arguments = {}) ⇒ Object

Get a list of all aliases, or aliases for a specific index.

Examples:

Get a list of all aliases


client.indices.get_aliases

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names to filter aliases

  • :name (List)

    A comma-separated list of alias names to filter

  • :timeout (Time)

    Explicit timestamp for the document

  • :local (Boolean)

    Return local information, do not retrieve the state from master node (default: false)

See Also:



20
21
22
23
24
25
26
27
28
# File 'lib/elasticsearch/api/actions/indices/get_aliases.rb', line 20

def get_aliases(arguments={})
  method = HTTP_GET
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_aliases', Utils.__listify(arguments[:name])

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = nil

  perform_request(method, path, params, body).body
end

#get_field_mapping(arguments = {}) ⇒ Object

Return the mapping definition for specific field (or fields)

Examples:

Get mapping for a specific field across all indices


client.indices.get_field_mapping field: 'foo'

Get mapping for a specific field in an index


client.indices.get_field_mapping index: 'foo', field: 'bar'

Get mappings for multiple fields in an index


client.indices.get_field_mapping index: 'foo', field: ['bar', 'bam']

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names

  • :type (List)

    A comma-separated list of document types

  • :field (List)

    A comma-separated list of fields (Required)

  • :include_defaults (Boolean)

    Whether default mapping values should be returned as well

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :ignore_indices (String)

    When performed on multiple indices, allows to ignore `missing` ones (options: none, missing) @until 1.0

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

Raises:

  • (ArgumentError)

See Also:



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# File 'lib/elasticsearch/api/actions/indices/get_field_mapping.rb', line 36

def get_field_mapping(arguments={})
  arguments = arguments.clone
  fields = arguments.delete(:field) || arguments.delete(:fields)
  raise ArgumentError, "Required argument 'field' missing" unless fields
  method = HTTP_GET
  path   = Utils.__pathify(
             Utils.__listify(arguments[:index]),
             '_mapping',
             Utils.__listify(arguments[:type]),
             'field',
             Utils.__listify(fields)
           )
  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = nil

  perform_request(method, path, params, body).body
end

#get_mapping(arguments = {}) ⇒ Object

Return the mapping definitions for all indices, or specific indices/types.

Examples:

Get all mappings in the cluster


client.indices.get_mapping

Get mapping for a specific index


client.indices.get_mapping index: 'foo'

Get mapping for a specific type in a specific index


client.indices.get_mapping index: 'foo', type: 'baz'

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names; use `_all` or empty string for all indices

  • :type (List)

    A comma-separated list of document types

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :ignore_indices (String)

    When performed on multiple indices, allows to ignore `missing` ones (options: none, missing) @until 1.0

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

  • :local (Boolean)

    Return local information, do not retrieve the state from master node (default: false)

See Also:



36
37
38
39
40
41
42
43
44
45
# File 'lib/elasticsearch/api/actions/indices/get_mapping.rb', line 36

def get_mapping(arguments={})
  method = HTTP_GET
  path   = Utils.__pathify Utils.__listify(arguments[:index]),
                           '_mapping',
                           Utils.__listify(arguments[:type])
  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body = nil

  perform_request(method, path, params, body).body
end

#get_settings(arguments = {}) ⇒ Object

Return the settings for all indices, or a list of indices.

Examples:

Get settings for all indices


client.indices.get_settings

Get settings for the 'foo' index


client.indices.get_settings index: 'foo'

Get settings for indices beginning with foo


client.indices.get_settings prefix: 'foo'

Get settings for an index named myindex


client.indices.get_settings index: 'myindex'

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices

  • :name (List)

    The name of the settings that should be included in the response

  • :prefix (String)

    The prefix all settings must have in order to be included

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :ignore_indices (String)

    When performed on multiple indices, allows to ignore `missing` ones (options: none, missing) @until 1.0

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

  • :include_defaults (Boolean)

    Whether to return all default clusters setting

  • :flat_settings (Boolean)

    Return settings in flat format (default: false)

  • :local (Boolean)

    Return local information, do not retrieve the state from master node (default: false)

See Also:



44
45
46
47
48
49
50
51
52
53
54
55
# File 'lib/elasticsearch/api/actions/indices/get_settings.rb', line 44

def get_settings(arguments={})
  method = HTTP_GET
  path   = Utils.__pathify Utils.__listify(arguments[:index]),
                           Utils.__listify(arguments[:type]),
                           arguments.delete(:prefix),
                           '_settings',
                           Utils.__escape(arguments[:name])
  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = nil

  perform_request(method, path, params, body).body
end

#get_template(arguments = {}) ⇒ Object

Note:

Use the Cluster::Actions#state API to get a list of all templates.

Get a single index template.

Examples:

Get all templates


client.indices.get_template

Get a template named mytemplate


client.indices.get_template name: 'mytemplate'

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :name (String)

    The name of the template (supports wildcards)

  • :flat_settings (Boolean)

    Return settings in flat format (default: false)

  • :local (Boolean)

    Return local information, do not retrieve the state from master node (default: false)

  • :master_timeout (Time)

    Explicit operation timeout for connection to master node

See Also:



26
27
28
29
30
31
32
33
34
# File 'lib/elasticsearch/api/actions/indices/get_template.rb', line 26

def get_template(arguments={})
  method = HTTP_GET
  path   = Utils.__pathify '_template', Utils.__escape(arguments[:name])

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = arguments[:body]

  perform_request(method, path, params, body).body
end

#get_warmer(arguments = {}) ⇒ Object

Get one or more warmers for an index.

Examples:

Get all warmers


client.indices.get_warmer index: '_all'

Get all warmers matching a wildcard expression


client.indices.get_warmer index: '_all', name: 'ba*'

Get all warmers for a single index


client.indices.get_warmer index: 'foo'

Get a specific warmer


client.indices.get_warmer index: 'foo', name: 'bar'

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices (Required)

  • :name (String)

    The name of the warmer (supports wildcards); leave empty to get all warmers

  • :type (List)

    A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :ignore_indices (String)

    When performed on multiple indices, allows to ignore `missing` ones (options: none, missing) @until 1.0

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

See Also:



41
42
43
44
45
46
47
48
# File 'lib/elasticsearch/api/actions/indices/get_warmer.rb', line 41

def get_warmer(arguments={})
  method = HTTP_GET
  path   = Utils.__pathify( Utils.__listify(arguments[:index]), '_warmer', Utils.__escape(arguments[:name]) )
  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = nil

  perform_request(method, path, params, body).body
end

#open(arguments = {}) ⇒ Object

Open a previously closed index (see the #close API).

Examples:

Open index named myindex


client.indices.open index: 'myindex'

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma separated list of indices to perform the operation on (Required)

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :ignore_indices (String)

    When performed on multiple indices, allows to ignore `missing` ones (options: none, missing) @until 1.0

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

  • :timeout (Time)

    Explicit operation timeout

  • :wait_for_active_shards (Number)

    Wait until the specified number of shards is active

Raises:

  • (ArgumentError)

See Also:



28
29
30
31
32
33
34
35
36
37
# File 'lib/elasticsearch/api/actions/indices/open.rb', line 28

def open(arguments={})
  raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
  method = HTTP_POST
  path   = Utils.__pathify Utils.__escape(arguments[:index]), '_open'

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body = nil

  perform_request(method, path, params, body).body
end

#optimize(arguments = {}) ⇒ Object

Deprecated.

The “optimize” action has been deprecated in favor of forcemerge [github.com/elastic/elasticsearch/pull/13778]

Note:

The optimize operation is handled automatically by Elasticsearch, you don't need to perform it manually. The operation is expensive in terms of resources (I/O, CPU, memory) and can take a long time to finish, potentially reducing operability of your cluster; schedule the manual optimization accordingly.

Perform an index optimization.

The “optimize” operation merges the index segments, increasing search performance. It corresponds to a Lucene “merge” operation.

Examples:

Fully optimize an index (merge to one segment)


client.indices.optimize index: 'foo', max_num_segments: 1, wait_for_merge: false

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :flush (Boolean)

    Specify whether the index should be flushed after performing the operation (default: true)

  • :force (Boolean)

    Force a merge operation to run, even when the index has a single segment (default: true)

  • :ignore_indices (String)

    When performed on multiple indices, allows to ignore `missing` ones (options: none, missing) @until 1.0

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

  • :max_num_segments (Number)

    The number of segments the index should be merged into (default: dynamic)

  • :master_timeout (Time)

    Specify timeout for connection to master

  • :only_expunge_deletes (Boolean)

    Specify whether the operation should only expunge deleted documents

  • :refresh (Boolean)

    Specify whether the index should be refreshed after performing the operation (default: true)

  • :wait_for_merge (Boolean)

    Specify whether the request should block until the merge process is finished (default: true)

See Also:



48
49
50
51
52
53
54
55
56
# File 'lib/elasticsearch/api/actions/indices/optimize.rb', line 48

def optimize(arguments={})
  method = HTTP_POST
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_optimize'

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body = nil

  perform_request(method, path, params, body).body
end

#put_alias(arguments = {}) ⇒ Object

Create or update a single index alias.

See the #update_aliases for performing operations with index aliases in bulk.

Examples:

Create an alias for current month


client.indices.put_alias index: 'logs-2013-06', name: 'current-month'

Create an alias for multiple indices


client.indices.put_alias index: 'logs-2013-06', name: 'year-2013'
client.indices.put_alias index: 'logs-2013-05', name: 'year-2013'

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (String)

    The name of the index with an alias (Required)

  • :name (String)

    The name of the alias to be created or updated (Required)

  • :body (Hash)

    The settings for the alias, such as `routing` or `filter`

  • :timeout (Time)

    Explicit timestamp for the document

Raises:

  • (ArgumentError)

See Also:



26
27
28
29
30
31
32
33
34
35
36
# File 'lib/elasticsearch/api/actions/indices/put_alias.rb', line 26

def put_alias(arguments={})
  raise ArgumentError, "Required argument 'index' missing"  unless arguments[:index]
  raise ArgumentError, "Required argument 'name' missing"  unless arguments[:name]
  method = HTTP_PUT
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_alias', Utils.__escape(arguments[:name])

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = arguments[:body]

  perform_request(method, path, params, body).body
end

#put_mapping(arguments = {}) ⇒ Object

Create or update mapping.

Pass the mapping definition(s) in the `:body` argument.

Examples:

Create or update a mapping for a specific document type


client.indices.put_mapping index: 'myindex', type: 'mytype', body: {
  mytype: {
    properties: {
      title: { type: 'string', analyzer: 'snowball' }
    }
  }
}

Update the mapping for a specific type in all indices


client.indices.put_mapping type: 'mytype', body: {
  mytype: {
    dynamic: 'strict'
  }
}

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :body (Hash)

    The mapping definition (Required)

  • :index (List)

    A comma-separated list of index names; use `_all` or omit to update the mapping for all indices

  • :type (String)

    The name of the document type (Required)

  • :ignore_conflicts (Boolean)

    Specify whether to ignore conflicts while updating the mapping (default: false)

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :ignore_indices (String)

    When performed on multiple indices, allows to ignore `missing` ones (options: none, missing) @until 1.0

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

  • :update_all_types (Boolean)

    Whether to update the mapping for all fields with the same name across all types

  • :timeout (Time)

    Explicit operation timeout

  • :master_timeout (Boolean)

    Timeout for connection to master

Raises:

  • (ArgumentError)

See Also:



50
51
52
53
54
55
56
57
58
59
60
# File 'lib/elasticsearch/api/actions/indices/put_mapping.rb', line 50

def put_mapping(arguments={})
  raise ArgumentError, "Required argument 'type' missing"  unless arguments[:type]
  raise ArgumentError, "Required argument 'body' missing"  unless arguments[:body]
  method = HTTP_PUT
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_mapping', Utils.__escape(arguments[:type])

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = arguments[:body]

  perform_request(method, path, params, body).body
end

#put_settings(arguments = {}) ⇒ Object

Update the settings for one or multiple indices.

Examples:

Change the number of replicas for all indices


client.indices.put_settings body: { index: { number_of_replicas: 0 } }

Change the number of replicas for a specific index


client.indices.put_settings index: 'myindex', body: { index: { number_of_replicas: 0 } }

Disable “flush” for all indices


client.indices.put_settings body: { 'index.translog.disable_flush' => true }

Allocate specific index on specific nodes


client.indices.put_settings index: 'my-big-index',
                            body: { 'index.routing.allocation.require.tag' => 'bigbox' }

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :body (Hash)

    The index settings to be updated (Required)

  • :index (List)

    A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :ignore_indices (String)

    When performed on multiple indices, allows to ignore `missing` ones (options: none, missing) @until 1.0

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

  • :include_defaults (Boolean)

    Whether to return all default clusters setting

  • :preserve_existing (Boolean)

    Whether to update existing settings. If set to `true` existing settings on an index remain unchanged, the default is `false`

  • :master_timeout (Time)

    Specify timeout for connection to master

  • :flat_settings (Boolean)

    Return settings in flat format (default: false)

Raises:

  • (ArgumentError)

See Also:



48
49
50
51
52
53
54
55
56
# File 'lib/elasticsearch/api/actions/indices/put_settings.rb', line 48

def put_settings(arguments={})
  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  method = HTTP_PUT
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_settings'
  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = arguments[:body]

  perform_request(method, path, params, body).body
end

#put_template(arguments = {}) ⇒ Object

Create or update an index template.

Examples:

Create a template for all indices starting with `logs-`


client.indices.put_template name: 'foo',
                            body: { template: 'logs-*', settings: { 'index.number_of_shards' => 1 } }

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :name (String)

    The name of the template (Required)

  • :body (Hash)

    The template definition (Required)

  • :create (Boolean)

    Whether the index template should only be added for a new one, # or can also replace an existing one (default: false)

  • :order (Number)

    The order for this template when merging multiple matching ones (higher numbers are merged later, overriding the lower numbers)

  • :timeout (Time)

    Explicit operation timeout

  • :master_timeout (Time)

    Specify timeout for connection to master

  • :flat_settings (Boolean)

    Return settings in flat format (default: false)

Raises:

  • (ArgumentError)

See Also:



24
25
26
27
28
29
30
31
32
33
34
# File 'lib/elasticsearch/api/actions/indices/put_template.rb', line 24

def put_template(arguments={})
  raise ArgumentError, "Required argument 'name' missing" unless arguments[:name]
  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  method = HTTP_PUT
  path   = Utils.__pathify '_template', Utils.__escape(arguments[:name])

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = arguments[:body]

  perform_request(method, path, params, body).body
end

#put_warmer(arguments = {}) ⇒ Object

Create or update an index warmer.

An index warmer will run before an index is refreshed, ie. available for search. It allows you to register “heavy” queries with popular filters, facets or sorts, increasing performance when the index is searched for the first time.

Examples:

Register a warmer which will populate the caches for `published` filter and sorting on `created_at`


client.indices.put_warmer index: 'myindex',
                          name: 'main',
                          body: {
                            query: { filtered: { filter: { term: { published: true } } } },
                            sort:  [ "created_at" ]
                          }

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names to register the warmer for; use `_all` or empty string to perform the operation on all indices (Required)

  • :name (String)

    The name of the warmer (Required)

  • :type (List)

    A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types

  • :body (Hash)

    The search request definition for the warmer (query, filters, facets, sorting, etc) (Required)

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :ignore_indices (String)

    When performed on multiple indices, allows to ignore `missing` ones (options: none, missing) @until 1.0

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

Raises:

  • (ArgumentError)

See Also:



40
41
42
43
44
45
46
47
48
49
50
51
52
# File 'lib/elasticsearch/api/actions/indices/put_warmer.rb', line 40

def put_warmer(arguments={})
  raise ArgumentError, "Required argument 'name' missing"  unless arguments[:name]
  raise ArgumentError, "Required argument 'body' missing"  unless arguments[:body]
  method = HTTP_PUT
  path   = Utils.__pathify( Utils.__listify(arguments[:index]),
                            Utils.__listify(arguments[:type]),
                            '_warmer',
                            Utils.__listify(arguments[:name]) )
  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = arguments[:body]

  perform_request(method, path, params, body).body
end

#recovery(arguments = {}) ⇒ Object

Return information about shard recovery for one or more indices

Examples:

Get recovery information for a single index


client.indices.recovery index: 'foo'

Get detailed recovery information for multiple indices


client.indices.recovery index: ['foo', 'bar'], detailed: true

Get recovery information for all indices


client.indices.recovery

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices

  • :detailed (Boolean)

    Whether to display detailed information about shard recovery

  • :active_only (Boolean)

    Display only those recoveries that are currently on-going

  • :human (Boolean)

    Whether to return time and byte values in human readable format

See Also:



27
28
29
30
31
32
33
34
# File 'lib/elasticsearch/api/actions/indices/recovery.rb', line 27

def recovery(arguments={})
  method = HTTP_GET
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_recovery'
  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = nil

  perform_request(method, path, params, body).body
end

#refresh(arguments = {}) ⇒ Object

Note:

The refresh operation can adversely affect indexing throughput when used too frequently.

Refresh the index and to make the changes (creates, updates, deletes) searchable.

By default, Elasticsearch has a delay of 1 second until changes to an index are available for search; the delay is configurable, see #put_settings.

You can trigger this operation explicitly, for example when performing a sequence of commands in integration tests, or when you need to perform a manual “synchronization” of the index with an external system at given moment.

Examples:

Refresh an index named myindex


client.indices.refresh index: 'myindex'

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :ignore_indices (String)

    When performed on multiple indices, allows to ignore `missing` ones (options: none, missing) @until 1.0

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

See Also:



35
36
37
38
39
40
41
42
43
# File 'lib/elasticsearch/api/actions/indices/refresh.rb', line 35

def refresh(arguments={})
  method = HTTP_POST
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_refresh'

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = nil

  perform_request(method, path, params, body).body
end

#rollover(arguments = {}) ⇒ Object

The rollover index API rolls an alias over to a new index when the existing index is considered to be too large or too old

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :alias (String)

    The name of the alias to rollover (Required)

  • :new_index (String)

    The name of the rollover index

  • :body (Hash)

    The conditions that needs to be met for executing rollover

  • :wait_for_active_shards (Number)

    Wait until the specified number of shards is active

  • :timeout (Time)

    Explicit operation timeout

  • :master_timeout (Time)

    Specify timeout for connection to master

  • :dry_run (Boolean)

    If set to true the rollover action will only be validated but not actually performed even if a condition matches. The default is false

Raises:

  • (ArgumentError)

See Also:



19
20
21
22
23
24
25
26
27
28
29
30
# File 'lib/elasticsearch/api/actions/indices/rollover.rb', line 19

def rollover(arguments={})
  raise ArgumentError, "Required argument 'alias' missing" unless arguments[:alias]
  arguments = arguments.clone
  source = arguments.delete(:alias)
  target = arguments.delete(:new_index)
  method = HTTP_POST
  path   = Utils.__pathify Utils.__escape(source), '_rollover', Utils.__escape(target)
  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = arguments[:body]

  perform_request(method, path, params, body).body
end

#seal(arguments = {}) ⇒ Object

“Seal” and index or indices for faster recovery

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names; use `_all` or empty string for all indices

See Also:



13
14
15
16
17
18
19
20
# File 'lib/elasticsearch/api/actions/indices/seal.rb', line 13

def seal(arguments={})
  method = 'POST'
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_seal'
  params = {}
  body   = nil

  perform_request(method, path, params, body).body
end

#segments(arguments = {}) ⇒ Object

Return information about segments for one or more indices.

The response contains information about segment size, number of documents, deleted documents, etc. See also #optimize.

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :ignore_indices (String)

    When performed on multiple indices, allows to ignore `missing` ones (options: none, missing) @until 1.0

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

  • :verbose (Boolean)

    Whether to include detailed memory usage by Lucene (default: false)

See Also:



26
27
28
29
30
31
32
33
34
# File 'lib/elasticsearch/api/actions/indices/segments.rb', line 26

def segments(arguments={})
  method = HTTP_GET
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_segments'

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = nil

  perform_request(method, path, params, body).body
end

#shard_stores(arguments = {}) ⇒ Object

Provides low-level information about shards (allocated nodes, exceptions, …)

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices

  • :status (List)

    A comma-separated list of statuses used to filter on shards to get store information for (options: green, yellow, red, all)

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing or closed)

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, none, all)

  • :operation_threading (String)

See Also:



17
18
19
20
21
22
23
24
# File 'lib/elasticsearch/api/actions/indices/shard_stores.rb', line 17

def shard_stores(arguments={})
  method = 'GET'
  path   = Utils.__pathify Utils.__escape(arguments[:index]), "_shard_stores"
  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = nil

  perform_request(method, path, params, body).body
end

#shrink(arguments = {}) ⇒ Object

Copy an existing index into a new index with a fewer number of primary shards

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (String)

    The name of the source index to shrink (Required)

  • :target (String)

    The name of the target index to shrink into (Required)

  • :body (Hash)

    The configuration for the target index (`settings` and `aliases`)

  • :wait_for_active_shards (Number)

    Wait until the specified number of shards is active

  • :wait_for_no_relocating_shards (Boolean)

    Whether to wait until there are no relocating shards in the cluster

  • :timeout (Time)

    Explicit operation timeout

  • :master_timeout (Time)

    Specify timeout for connection to master

Raises:

  • (ArgumentError)

See Also:



19
20
21
22
23
24
25
26
27
28
29
30
31
32
# File 'lib/elasticsearch/api/actions/indices/shrink.rb', line 19

def shrink(arguments={})
  raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
  raise ArgumentError, "Required argument 'target' missing" unless arguments[:target]
  arguments = arguments.clone
  source = arguments.delete(:index)
  target = arguments.delete(:target)

  method = HTTP_PUT
  path   = Utils.__pathify(source, '_shrink', target)
  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = arguments[:body]

  perform_request(method, path, params, body).body
end

#snapshot_index(arguments = {}) ⇒ Object

Deprecated.

The shared gateway has been deprecated [github.com/elasticsearch/elasticsearch/issues/2458]

When using the shared storage gateway, manually trigger the snapshot operation.

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :ignore_indices (String)

    When performed on multiple indices, allows to ignore `missing` ones (options: none, missing) @until 1.0

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

See Also:



24
25
26
27
28
29
30
31
# File 'lib/elasticsearch/api/actions/indices/snapshot_index.rb', line 24

def snapshot_index(arguments={})
  method = HTTP_POST
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_gateway/snapshot'
  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = nil

  perform_request(method, path, params, body).body
end

#split(arguments = {}) ⇒ Object

The split index API allows you to split an existing index into a new index, where each original primary shard is split into two or more primary shards in the new index.

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (String)

    The name of the source index to split (Required)

  • :target (String)

    The name of the target index to split into (Required)

  • :body (Hash)

    The configuration for the target index (`settings` and `aliases`)

  • :timeout (Time)

    Explicit operation timeout

  • :master_timeout (Time)

    Specify timeout for connection to master

  • :wait_for_active_shards (String)

    Set the number of active shards to wait for on the shrunken index before the operation returns.

Raises:

  • (ArgumentError)

See Also:



18
19
20
21
22
23
24
25
26
27
28
29
30
31
# File 'lib/elasticsearch/api/actions/indices/split.rb', line 18

def split(arguments={})
  raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
  raise ArgumentError, "Required argument 'target' missing" unless arguments[:target]
  arguments = arguments.clone
  source = arguments.delete(:index)
  target = arguments.delete(:target)

  method = Elasticsearch::API::HTTP_PUT
  path   = Utils.__pathify Utils.__escape(source), '_split', Utils.__escape(target)
  params = Elasticsearch::API::Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = arguments[:body]

  perform_request(method, path, params, body).body
end

#stats(arguments = {}) ⇒ Object

Return statistical information about one or more indices.

The response contains comprehensive statistical information about metrics related to index: how much time did indexing, search and other operations take, how much disk space it takes, how much memory filter caches or field data require, etc.

Examples:

Get all available statistics for all indices


client.indices.stats

Get statistics for a single index


client.indices.stats index: 'foo'

Get statistics about documents and disk size for multiple indices


client.indices.stats index: ['foo', 'bar'], docs: true, store: true

Get statistics about filter cache and field data for all fields


client.indices.stats fielddata: true, filter_cache: true

Get statistics about filter cache and field data for specific fields


client.indices.stats fielddata: true, filter_cache: true, fields: 'created_at,tags'

Get statistics about filter cache and field data per field for all fields


client.indices.stats fielddata: true, filter_cache: true, fields: '*'

Get statistics about searches, with segmentation for different search groups


client.indices.stats search: true, groups: ['groupA', 'groupB']

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :docs (Boolean)

    Return information about indexed and deleted documents

  • :fielddata (Boolean)

    Return information about field data

  • :fields (Boolean)

    A comma-separated list of fields for `fielddata` metric (supports wildcards)

  • :filter_cache (Boolean)

    Return information about filter cache

  • :flush (Boolean)

    Return information about flush operations

  • :get (Boolean)

    Return information about get operations

  • :groups (Boolean)

    A comma-separated list of search groups for `search` statistics

  • :id_cache (Boolean)

    Return information about ID cache

  • :index (List)

    A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices

  • :indexing (Boolean)

    Return information about indexing operations

  • :level (String)

    Return stats aggregated at cluster, index or shard level (Options: cluster, indices, shards)

  • :types (List)

    A comma-separated list of document types to include in the `indexing` info

  • :merge (Boolean)

    Return information about merge operations

  • :metric (List)

    Limit the information returned the specific metrics (_all, completion, docs, fielddata, filter_cache, flush, get, id_cache, indexing, merge, percolate, refresh, search, segments, store, warmer, suggest)

  • :refresh (Boolean)

    Return information about refresh operations

  • :search (Boolean)

    Return information about search operations; use the `groups` parameter to include information for specific search groups

  • :groups (List)

    A comma-separated list of search groups to include in the `search` statistics

  • :suggest (Boolean)

    Return information about suggest statistics

  • :store (Boolean)

    Return information about the size of the index

  • :warmer (Boolean)

    Return information about warmers

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :include_segment_file_sizes (Boolean)

    Whether to report the aggregated disk usage of each one of the Lucene index files. Only applies if segment stats are requested. (default: false)

See Also:



78
79
80
81
82
83
84
85
86
87
88
89
90
# File 'lib/elasticsearch/api/actions/indices/stats.rb', line 78

def stats(arguments={})
  method = HTTP_GET
  parts  = Utils.__extract_parts arguments, ParamsRegistry.get(:stats_parts)
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_stats', Utils.__listify(parts)

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(:stats_params)
  params[:fields] = Utils.__listify(params[:fields], :escape => false) if params[:fields]
  params[:groups] = Utils.__listify(params[:groups], :escape => false) if params[:groups]

  body   = nil

  perform_request(method, path, params, body).body
end

#status(arguments = {}) ⇒ Object

Return information about one or more indices

Examples:

Get information about all indices


client.indices.status

Get information about a specific index


client.indices.status index: 'foo'

Get information about shard recovery for a specific index


client.indices.status index: 'foo', recovery: true

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :ignore_indices (String)

    When performed on multiple indices, allows to ignore `missing` ones (options: none, missing) @until 1.0

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing, closed, etc)

  • :recovery (Boolean)

    Return information about shard recovery (progress, size, etc)

  • :snapshot (Boolean)

    Return information about snapshots (when shared gateway is used)

See Also:



36
37
38
39
40
41
42
43
44
45
46
47
48
# File 'lib/elasticsearch/api/actions/indices/status.rb', line 36

def status(arguments={})
  method = HTTP_GET
  path   = Utils.__pathify Utils.__listify(arguments[:index]), '_status'

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = nil

  if Array(arguments[:ignore]).include?(404)
    Utils.__rescue_from_not_found { perform_request(method, path, params, body).body }
  else
    perform_request(method, path, params, body).body
  end
end

#unfreeze(arguments = {}) ⇒ Object

Note:

This feature is available in the Platinum distribution of Elasticsearch.

In order to keep indices available and queryable for a longer period but at the same time reduce their

hardware requirements they can be transitioned into a frozen state. Once an index is frozen, all of its
transient shard memory (aside from mappings and analyzers) is moved to persistent storage.

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma separated list of indices to unfreeze. (Required)

Raises:

  • (ArgumentError)

See Also:



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# File 'lib/elasticsearch/api/actions/indices/unfreeze.rb', line 16

def unfreeze(arguments = {})
  raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]

  valid_params = [
      :timeout,
      :master_timeout,
      :ignore_unavailable,
      :allow_no_indices,
      :expand_wildcards,
      :wait_for_active_shards]

  arguments = arguments.clone
  index = arguments.delete(:index)

  method = Elasticsearch::API::HTTP_POST
  path = Elasticsearch::API::Utils.__pathify Elasticsearch::API::Utils.__listify(index), '_unfreeze'
  params = Elasticsearch::API::Utils.__validate_and_extract_params arguments, valid_params

  perform_request(method, path, params).body
end

#update_aliases(arguments = {}) ⇒ Object

Perform multiple operation on index aliases in a single request.

Pass the `actions` (add, remove) in the `body` argument.

Examples:

Add multiple indices to a single alias


client.indices.update_aliases body: {
  actions: [
    { add: { index: 'logs-2013-06', alias: 'year-2013' } },
    { add: { index: 'logs-2013-05', alias: 'year-2013' } }
  ]
}

Swap an alias (atomic operation)


client.indices.update_aliases body: {
  actions: [
    { remove: { index: 'logs-2013-06', alias: 'current-month' } },
    { add:    { index: 'logs-2013-07', alias: 'current-month' } }
  ]
}

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :body (Hash)

    The operations definition and other configuration (Required)

  • :timeout (Time)

    Explicit operation timeout

Raises:

  • (ArgumentError)

See Also:



33
34
35
36
37
38
39
40
41
42
# File 'lib/elasticsearch/api/actions/indices/update_aliases.rb', line 33

def update_aliases(arguments={})
  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  method = HTTP_POST
  path   = "_aliases"

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = arguments[:body]

  perform_request(method, path, params, body).body
end

#upgrade(arguments = {}) ⇒ Object

Upgrade the index or indices to the latest Lucene format.

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing or closed)

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices.

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed)

  • :wait_for_completion (Boolean)

    Specify whether the request should block until the all segments are upgraded (default: true)

See Also:



21
22
23
24
25
26
27
28
# File 'lib/elasticsearch/api/actions/indices/upgrade.rb', line 21

def upgrade(arguments={})
  method = HTTP_POST
  path   = "_upgrade"
  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = nil

  perform_request(method, path, params, body).body
end

#validate_query(arguments = {}) ⇒ Object

Validate a query

client.indices.validate_query index: 'myindex',
                              rewrite: true,
                              explain: true,
                              body: {
                                filtered: {
                                  query: {
                                    match: {
                                      title: 'foo'
                                    }
                                  },
                                  filter: {
                                    range: {
                                      published_at: {
                                        from: '2013-06-01'
                                      }
                                    }
                                  }
                                }
                              }

Examples:

Validate a simple query string query


client.indices.validate_query index: 'myindex', q: 'title:foo AND body:bar'

Validate an invalid query (with explanation)


client.indices.validate_query index: 'myindex', q: '[[[ BOOM! ]]]', explain: true

Validate a DSL query (with explanation and rewrite). With rewrite set to true, the

explanation is more detailed showing the actual Lucene query that will 
be executed.

Parameters:

  • arguments (Hash) (defaults to: {})

    a customizable set of options

Options Hash (arguments):

  • :index (List)

    A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices

  • :type (List)

    A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types

  • :body (Hash)

    The query definition specified with the Query DSL

  • :explain (Boolean)

    Return detailed information about the error

  • :ignore_unavailable (Boolean)

    Whether specified concrete indices should be ignored when unavailable (missing or closed)

  • :allow_no_indices (Boolean)

    Whether to ignore if a wildcard indices expression resolves into no concrete indices.

  • :expand_wildcards (String)

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, none, all)

  • :operation_threading (String)

    TODO: ?

  • :q (String)

    Query in the Lucene query string syntax

  • :analyzer (String)

    The analyzer to use for the query string

  • :analyze_wildcard (Boolean)

    Specify whether wildcard and prefix queries should be analyzed (default: false)

  • :default_operator (String)

    The default operator for query string query (AND or OR) (options: AND, OR)

  • :df (String)

    The field to use as default where no field prefix is given in the query string

  • :lenient (Boolean)

    Specify whether format-based query failures (such as providing text to a numeric field) should be ignored

  • :lowercase_expanded_terms (Boolean)

    Specify whether query terms should be lowercased

See Also:



68
69
70
71
72
73
74
75
76
77
78
# File 'lib/elasticsearch/api/actions/indices/validate_query.rb', line 68

def validate_query(arguments={})
  method = HTTP_GET
  path   = Utils.__pathify Utils.__listify(arguments[:index]),
                           Utils.__listify(arguments[:type]),
                           '_validate/query'

  params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
  body   = arguments[:body]

  perform_request(method, path, params, body).body
end