Define query on the search request body using the Query DSL.

Sets knn on the search request body.

Sets aggregation on the request body. Alias for method aggregation

• TypeError: If agg is not an instance of Aggregation

Sets aggregation on the request body.

• TypeError: If agg is not an instance of Aggregation

Sets multiple nested aggregation items. Alias for method aggregations

• TypeError: If aggs is not an instance of Array
• TypeError: If aggs contains instances not of type Aggregation

Sets multiple nested aggregation items. This method accepts an array to set multiple nested aggregations in one call.

• TypeError: If aggs is not an instance of Array
• TypeError: If aggs contains instances not of type Aggregation

Sets suggester on the request body.

• TypeError: If suggest is not an instance of Suggester

const req = esb.requestBodySearch()
    .query(esb.matchQuery('message', 'trying out elasticsearch'))
    .suggest(
        esb.termSuggester(
            'my-suggestion',
            'message',
            'tring out Elasticsearch'
        )
    );

Sets the global suggest text to avoid repetition for multiple suggestions.

const req = esb.requestBodySearch()
    .suggestText('tring out elasticsearch')
    .suggest(esb.termSuggester('my-suggest-1', 'message'))
    .suggest(esb.termSuggester('my-suggest-2', 'user'));

Sets a search timeout, bounding the search request to be executed within the specified time value and bail with the hits accumulated up to that point when expired.

To retrieve hits from a certain offset.

The number of hits to return. If you do not care about getting some hits back but only about the number of matches and/or aggregations, setting the value to 0 will help performance.

The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early. If set, the response will have a boolean field terminated_early to indicate whether the query execution has actually terminated early.

Allows to add sort on specific field. The sort can be reversed as well. The sort is defined on a per field level, with special field name for _score to sort by score, and _doc to sort by index order.

• TypeError: If parameter sort is not an instance of Sort .

const reqBody = esb.requestBodySearch()
    .query(esb.termQuery('user', 'kimchy'))
    .sort(esb.sort('post_date', 'asc'))
    .sort(esb.sort('user'))
    .sorts([
        esb.sort('name', 'desc'),
        esb.sort('age', 'desc'),
        esb.sort('_score')
    ]);

Allows to add multiple sort on specific fields. Each sort can be reversed as well. The sort is defined on a per field level, with special field name for _score to sort by score, and _doc to sort by index order.

• TypeError: If any item in parameter sorts is not an instance of Sort .

const reqBody = esb.requestBodySearch()
    .query(esb.termQuery('user', 'kimchy'))
    .sort(esb.sort('post_date', 'asc'))
    .sort(esb.sort('user'))
    .sorts([
        esb.sort('name', 'desc'),
        esb.sort('age', 'desc'),
        esb.sort('_score')
    ]);

When sorting on a field, scores are not computed. By setting track_scores to true, scores will still be computed and tracked.

const reqBody = esb.requestBodySearch()
    .trackScores(true)
    .sorts([
        esb.sort('post_date', 'desc'),
        esb.sort('name', 'desc'),
        esb.sort('age', 'desc')
    ])
    .query(esb.termQuery('user', 'kimchy'));

The track_total_hits parameter allows you to control how the total number of hits should be tracked. Passing false can increase performance in some situations. (Added in elasticsearch@7)

Pass true, false, or the upper limit (default: 10000) of hits you want tracked.

Allows to control how the _source field is returned with every hit. You can turn off _source retrieval by passing false. It also accepts one(string) or more wildcard(array) patterns to control what parts of the _source should be returned An object can also be used to specify the wildcard patterns for includes and excludes.

// To disable `_source` retrieval set to `false`:
const reqBody = esb.requestBodySearch()
    .query(esb.termQuery('user', 'kimchy'))
    .source(false);

// The `_source` also accepts one or more wildcard patterns to control what
// parts of the `_source` should be returned:
const reqBody = esb.requestBodySearch()
    .query(esb.termQuery('user', 'kimchy'))
    .source('obj.*');

// OR
const reqBody = esb.requestBodySearch()
    .query(esb.termQuery('user', 'kimchy'))
    .source([ 'obj1.*', 'obj2.*' ]);

// For complete control, you can specify both `includes` and `excludes` patterns:
const reqBody = esb.requestBodySearch()
    .query(esb.termQuery('user', 'kimchy'))
    .source({
        'includes': [ 'obj1.*', 'obj2.*' ],
        'excludes': [ '*.description' ]
    });

The stored_fields parameter is about fields that are explicitly marked as stored in the mapping. Selectively load specific stored fields for each document represented by a search hit using array of stored fields. An empty array will cause only the _id and _type for each hit to be returned. To disable the stored fields (and metadata fields) entirely use: _none_

// Selectively load specific stored fields for each document
// represented by a search hit
const reqBody = esb.requestBodySearch()
    .query(esb.termQuery('user', 'kimchy'))
    .storedFields(['user', 'postDate']);

// Return only the `_id` and `_type` to be returned:
const reqBody = esb.requestBodySearch()
    .query(esb.termQuery('user', 'kimchy'))
    .storedFields([]);

// Disable the stored fields (and metadata fields) entirely
const reqBody = esb.requestBodySearch()
    .query(esb.termQuery('user', 'kimchy'))
    .storedFields('_none_');

Computes a document property dynamically based on the supplied runtimeField.

Elasticsearch reference

Added in Elasticsearch v7.11.0 Release note

const reqBody = esb.requestBodySearch()
    .query(esb.matchAllQuery())
    .runtimeMapping(
      'sessionId-name',
      esb.runtimeField(
        'keyword',
        `emit(doc['session_id'].value + '::' + doc['name'].value)`
      )
    )

// runtime fields can also be used in query aggregation
const reqBody = esb.requestBodySearch()
    .query(esb.matchAllQuery())
    .runtimeMapping(
      'sessionId-eventName',
      esb.runtimeField(
        'keyword',
        `emit(doc['session_id'].value + '::' + doc['eventName'].value)`,
      )
    )
    .agg(esb.cardinalityAggregation('uniqueCount', `sessionId-eventName`)),;

Computes one or more document properties dynamically based on supplied RuntimeFields.

Elasticsearch reference

Added in Elasticsearch v7.11.0 Release note

const fieldA = esb.runtimeField(
      'keyword',
      `emit(doc['session_id'].value + '::' + doc['name'].value)`
);
const reqBody = esb.requestBodySearch()
    .query(esb.matchAllQuery())
    .runtimeMappings({
      'sessionId-name': fieldA,
    })

Computes a document property dynamically based on the supplied Script.

const reqBody = esb.requestBodySearch()
    .query(esb.matchAllQuery())
    .scriptField(
        'test1',
        esb.script('inline', "doc['my_field_name'].value * 2").lang('painless')
    )
    .scriptField(
        'test2',
        esb.script('inline', "doc['my_field_name'].value * factor")
            .lang('painless')
            .params({ factor: 2.0 })
    );

// Script fields can also access the actual `_source` document and extract
// specific elements to be returned from it by using `params['_source']`.
const reqBody = esb.requestBodySearch()
    .query(esb.matchAllQuery())
    .scriptField('test1', "params['_source']['message']");

Sets given dynamic document properties to be computed using supplied Scripts.

Object should have scriptFieldName as key and script as the value.

const reqBody = esb.requestBodySearch()
    .query(esb.matchAllQuery())
    .scriptFields({
        test1: esb
            .script('inline', "doc['my_field_name'].value * 2")
            .lang('painless'),
        test2: esb
            .script('inline', "doc['my_field_name'].value * factor")
            .lang('painless')
            .params({ factor: 2.0 })
    });

// Script fields can also access the actual `_source` document and extract
// specific elements to be returned from it by using `params['_source']`.
const reqBody = esb.requestBodySearch()
    .query(esb.matchAllQuery())
    .scriptFields({ test1: "params['_source']['message']" });

Allows to return the doc value representation of a field for each hit. Doc value fields can work on fields that are not stored.

const reqBody = esb.requestBodySearch()
    .query(esb.matchAllQuery())
    .docvalueFields(['test1', 'test2']);

The post_filter is applied to the search hits at the very end of a search request, after aggregations have already been calculated.

const reqBody = esb.requestBodySearch()
    .query(esb.boolQuery().filter(esb.termQuery('brand', 'gucci')))
    .agg(esb.termsAggregation('colors', 'color'))
    .agg(
        esb.filterAggregation(
            'color_red',
            esb.termQuery('color', 'red')
        ).agg(esb.termsAggregation('models', 'model'))
    )
    .postFilter(esb.termQuery('color', 'red'));

Allows to highlight search results on one or more fields. The implementation uses either the lucene plain highlighter, the fast vector highlighter (fvh) or postings highlighter.

Note: The postings highlighter has been removed in elasticsearch 6.0. The unified highlighter outputs the same highlighting when index_options is set to offsets.

const reqBody = esb.requestBodySearch()
    .query(esb.matchAllQuery())
    .highlight(esb.highlight('content'));

const reqBody = esb.requestBodySearch()
    .query(
        esb.percolateQuery('query', 'doctype').document({
            message: 'The quick brown fox jumps over the lazy dog'
        })
    )
    .highlight(esb.highlight('message'));

Rescoring can help to improve precision by reordering just the top (eg 100 - 500) documents returned by the query and post_filter phases, using a secondary (usually more costly) algorithm, instead of applying the costly algorithm to all documents in the index.

• TypeError: If query is not an instance of Rescore

const reqBody = esb.requestBodySearch()
    .query(esb.matchQuery('message', 'the quick brown').operator('or'))
    .rescore(
        esb.rescore(
            50,
            esb.matchPhraseQuery('message', 'the quick brown').slop(2)
        )
            .queryWeight(0.7)
            .rescoreQueryWeight(1.2)
    );

const reqBody = esb.requestBodySearch()
    .query(esb.matchQuery('message', 'the quick brown').operator('or'))
    .rescore(
        esb.rescore(
            100,
            esb.matchPhraseQuery('message', 'the quick brown').slop(2)
        )
            .queryWeight(0.7)
            .rescoreQueryWeight(1.2)
    )
    .rescore(
        esb.rescore(
            10,
            esb.functionScoreQuery().function(
                esb.scriptScoreFunction(
                    esb.script('inline', 'Math.log10(doc.likes.value + 2)')
                )
            )
        ).scoreMode('multiply')
    );

Enables explanation for each hit on how its score was computed.

const reqBody = esb.requestBodySearch()
    .query(esb.termQuery('user', 'kimchy'))
    .explain(true);

Returns a version for each search hit.

const reqBody = esb.requestBodySearch()
    .query(esb.termQuery('user', 'kimchy'))
    .version(true);

Allows to configure different boost level per index when searching across more than one indices. This is very handy when hits coming from one index matter more than hits coming from another index.

Alias for method indicesBoost.

const reqBody = esb.requestBodySearch()
    .indexBoost('alias1', 1.4)
    .indexBoost('index*', 1.3);

Allows to configure different boost level per index when searching across more than one indices. This is very handy when hits coming from one index matter more than hits coming from another index.

const reqBody = esb.requestBodySearch()
    .indicesBoost('alias1', 1.4)
    .indicesBoost('index*', 1.3);

Exclude documents which have a _score less than the minimum specified in min_score.

const reqBody = esb.requestBodySearch()
    .query(esb.termQuery('user', 'kimchy'))
    .minScore(0.5);

Allows to collapse search results based on field values. The collapsing is done by selecting only the top sorted document per collapse key.

The field used for collapsing must be a single valued keyword or numeric field with doc_values activated

• TypeError: If innerHits is not an instance of InnerHits

const reqBody = esb.requestBodySearch()
    .query(esb.matchQuery('message', 'elasticsearch'))
    .collapse('user')
    .sort(esb.sort('likes'))
    .from(10);

// Expand each collapsed top hits with the `inner_hits` option:
const reqBody = esb.requestBodySearch()
    .query(esb.matchQuery('message', 'elasticsearch'))
    .collapse(
        'user',
        esb.innerHits('last_tweets')
            .size(5)
            .sort(esb.sort('date', 'asc')),
        4
    )
    .sort(esb.sort('likes'))
    .from(10);

Allows to use the results from the previous page to help the retrieval of the next page. The search_after parameter provides a live cursor.

The parameter from must be set to 0 (or -1) when search_after is used.

const reqBody = esb.requestBodySearch()
    .size(10)
    .query(esb.matchQuery('message', 'elasticsearch'))
    .searchAfter(1463538857, 'tweet#654323')
    .sorts([esb.sort('date', 'asc'), esb.sort('_uid', 'desc')]);

Override default toJSON to return DSL representation for the request body search

Sets the boost value for documents matching the Query.

Sets the query name.

const boolQry = esb.boolQuery()
    .should([
        esb.matchQuery('name.first', 'shay').name('first'),
        esb.matchQuery('name.last', 'banon').name('last')
    ])
    .filter(esb.termsQuery('name.last', ['banon', 'kimchy']).name('test'));

Build and returns DSL representation of the Query class instance.

Override default toJSON to return DSL representation for the query

Set the analyzer to control which analyzer will perform the analysis process on the text

const qry = esb.matchPhraseQuery('message', 'this is a test')
    .analyzer('my_analyzer');

const qry = esb.multiMatchQuery(['first', 'last', '*.edge'], 'Jon')
    .type('cross_fields')
    .analyzer('standard');

Sets the value controlling how many "should" clauses in the resulting boolean query should match. It can be an absolute value (2), a percentage (30%) or a combination of both. For Common Terms Query when specifying different minimum_should_match for low and high frequency terms, an object with the keys low_freq and high_freq can be used.

const qry = esb.commonTermsQuery('body', 'nelly the elephant as a cartoon')
    .minimumShouldMatch(2)
    .cutoffFrequency(0.001);

Sets the query string.

const qry = esb.queryStringQuery()
    .query('city.\\*:(this AND that OR thus)')
    .useDisMax(true);

Sets the field to search on.

Override default toJSON to return DSL representation of the Full text query class instance.

The operator to be used in the boolean query which is constructed by analyzing the text provided. The operator flag can be set to or or and to control the boolean clauses (defaults to or).

Sets the lenient parameter which allows to ignore exceptions caused by data-type mismatches such as trying to query a numeric field with a text query string when set to true.

Sets the fuzziness parameter which is interpreted as a Levenshtein Edit Distance — the number of one character changes that need to be made to one string to make it the same as another string.

Sets the prefix length for a fuzzy prefix MatchQuery

Sets the max expansions for a fuzzy prefix MatchQuery

Sets the rewrite method. Valid values are:

• constant_score - tries to pick the best constant-score rewrite method based on term and document counts from the query. Synonyms - constant_score_auto, constant_score_filter

• scoring_boolean - translates each term into boolean should and keeps the scores as computed by the query

• constant_score_boolean - same as scoring_boolean, expect no scores are computed.

• constant_score_filter - first creates a private Filter, by visiting each term in sequence and marking all docs for that term

• top_terms_boost_N - first translates each term into boolean should and scores are only computed as the boost using the top N scoring terms. Replace N with an integer value.

• top_terms_N - first translates each term into boolean should and keeps the scores as computed by the query. Only the top N scoring terms are used. Replace N with an integer value.

Default is constant_score.

Note: The deprecated multi term rewrite parameters constant_score_auto, constant_score_filter (synonyms for constant_score) have been removed in elasticsearch 6.0.

This is an advanced option, use with care.

• Error: If the given rewrite method is not valid.

Sets the fuzzy rewrite method. Valid values are:

• constant_score - tries to pick the best constant-score rewrite method based on term and document counts from the query. Synonyms - constant_score_auto, constant_score_filter

• scoring_boolean - translates each term into boolean should and keeps the scores as computed by the query

• constant_score_boolean - same as scoring_boolean, expect no scores are computed.

• constant_score_filter - first creates a private Filter, by visiting each term in sequence and marking all docs for that term

• top_terms_boost_N - first translates each term into boolean should and scores are only computed as the boost using the top N scoring terms. Replace N with an integer value.

• top_terms_N - first translates each term into boolean should and keeps the scores as computed by the query. Only the top N scoring terms are used. Replace N with an integer value.

Default is constant_score.

This is an advanced option, use with care.

Note: The deprecated multi term rewrite parameters constant_score_auto, constant_score_filter (synonyms for constant_score) have been removed in elasticsearch 6.0.

• Error: If the given fuzzy_rewrite method is not valid.

Fuzzy transpositions (ab → ba) are allowed by default but can be disabled by setting fuzzy_transpositions to false.

If the analyzer used removes all tokens in a query like a stop filter does, the default behavior is to match no documents at all. In order to change that the zero_terms_query option can be used, which accepts none (default) and all which corresponds to a match_all query.

const qry = esb.matchQuery('message', 'to be or not to be')
    .operator('and')
    .zeroTermsQuery('all');

Allows specifying an absolute or relative document frequency where high frequency terms are moved into an optional subquery and are only scored if one of the low frequency (below the cutoff) terms in the case of an or operator or all of the low frequency terms in the case of an and operator match.

const qry = esb.matchQuery('message', 'to be or not to be')
    .cutoffFrequency(0.001);

• Error: This method cannot be called on MatchPhraseQueryBase

Configures the slop(default is 0) for matching terms in any order. Transposed terms have a slop of 2.

Control to how many prefixes the last term will be expanded.

const qry = esb.matchPhrasePrefixQuery('message', 'quick brown f')
    .maxExpansions(10);

Appends given field to the list of fields to search against. Fields can be specified with wildcards. Individual fields can be boosted with the caret (^) notation. Example - "subject^3"

Appends given fields to the list of fields to search against. Fields can be specified with wildcards. Individual fields can be boosted with the caret (^) notation.

// Boost individual fields with caret `^` notation
const qry = esb.multiMatchQuery(['subject^3', 'message'], 'this is a test');

// Specify fields with wildcards
const qry = esb.multiMatchQuery(['title', '*_name'], 'Will Smith');

Sets the type of multi match query. Valid values are:

• best_fields - (default) Finds documents which match any field, but uses the _score from the best field.

• most_fields - Finds documents which match any field and combines the _score from each field.

• cross_fields - Treats fields with the same analyzer as though they were one big field. Looks for each word in any field

• phrase - Runs a match_phrase query on each field and combines the _score from each field.

• phrase_prefix - Runs a match_phrase_prefix query on each field and combines the _score from each field.

• bool_prefix - (added in v7.2) Creates a match_bool_prefix query on each field and combines the _score from each field.

// Find the single best matching field
const qry = esb.multiMatchQuery(['subject', 'message'], 'brown fox')
    .type('best_fields')
    .tieBreaker(0.3);

// Query multiple fields analyzed differently for the same text
const qry = esb.multiMatchQuery(
    ['title', 'title.original', 'title.shingles'],
    'quick brown fox'
).type('most_fields');

// Run a `match_phrase_prefix` query on multiple fields
const qry = esb.multiMatchQuery(
    ['subject', 'message'],
    'quick brown f'
).type('phrase_prefix');

// All terms must be present in at least one field for document to match
const qry = esb.multiMatchQuery(['first_name', 'last_name'], 'Will Smith')
    .type('cross_fields')
    .operator('and');

The tie breaker value. The tie breaker capability allows results that include the same term in multiple fields to be judged better than results that include this term in only the best of those multiple fields, without confusing this with the better case of two different terms in the multiple fields. Default: 0.0.

The operator to be used in the boolean query which is constructed by analyzing the text provided. The operator flag can be set to or or and to control the boolean clauses (defaults to or).

Sets the lenient parameter which allows to ignore exceptions caused by data-type mismatches such as trying to query a numeric field with a text query string when set to true.

Configures the slop(default is 0) for matching terms in any order. Transposed terms have a slop of 2.

Sets the fuzziness parameter which is interpreted as a Levenshtein Edit Distance — the number of one character changes that need to be made to one string to make it the same as another string.

The fuzziness parameter cannot be used with the phrase, phrase_prefix or cross_fields type.

Sets the prefix length for a fuzzy prefix MultiMatchQuery

Sets the max expansions for a fuzzy prefix MultiMatchQuery

Sets the rewrite method. Valid values are:

• constant_score - tries to pick the best constant-score rewrite method based on term and document counts from the query. Synonyms - constant_score_auto, constant_score_filter

• scoring_boolean - translates each term into boolean should and keeps the scores as computed by the query

• constant_score_boolean - same as scoring_boolean, expect no scores are computed.

• constant_score_filter - first creates a private Filter, by visiting each term in sequence and marking all docs for that term

• top_terms_boost_N - first translates each term into boolean should and scores are only computed as the boost using the top N scoring terms. Replace N with an integer value.

• top_terms_N - first translates each term into boolean should and keeps the scores as computed by the query. Only the top N scoring terms are used. Replace N with an integer value.

Default is constant_score.

This is an advanced option, use with care.

Note: The deprecated multi term rewrite parameters constant_score_auto, constant_score_filter (synonyms for constant_score) have been removed in elasticsearch 6.0.

• Error: If the given rewrite method is not valid.

Sets the fuzzy rewrite method. Valid values are:

• constant_score - tries to pick the best constant-score rewrite method based on term and document counts from the query. Synonyms - constant_score_auto, constant_score_filter

• scoring_boolean - translates each term into boolean should and keeps the scores as computed by the query

• constant_score_boolean - same as scoring_boolean, expect no scores are computed.

• constant_score_filter - first creates a private Filter, by visiting each term in sequence and marking all docs for that term

• top_terms_boost_N - first translates each term into boolean should and scores are only computed as the boost using the top N scoring terms. Replace N with an integer value.

• top_terms_N - first translates each term into boolean should and keeps the scores as computed by the query. Only the top N scoring terms are used. Replace N with an integer value.

Default is constant_score.

This is an advanced option, use with care.

Note: The deprecated multi term rewrite parameters constant_score_auto, constant_score_filter (synonyms for constant_score) have been removed in elasticsearch 6.0.

• Error: If the given fuzzy_rewrite method is not valid.

If the analyzer used removes all tokens in a query like a stop filter does, the default behavior is to match no documents at all. In order to change that the zero_terms_query option can be used, which accepts none (default) and all which corresponds to a match_all query.

Allows specifying an absolute or relative document frequency where high frequency terms are moved into an optional subquery and are only scored if one of the low frequency (below the cutoff) terms in the case of an or operator or all of the low frequency terms in the case of an and operator match.

Allows specifying an absolute or relative document frequency where high frequency terms are moved into an optional subquery and are only scored if one of the low frequency (below the cutoff) terms in the case of an or operator or all of the low frequency terms in the case of an and operator match.

The operator to be used on low frequency terms in the boolean query which is constructed by analyzing the text provided. The operator flag can be set to or or and to control the boolean clauses (defaults to or).

const qry = esb.commonTermsQuery('body', 'nelly the elephant as a cartoon')
    .lowFreqOperator('and')
    .cutoffFrequency(0.001);

The operator to be used on high frequency terms in the boolean query which is constructed by analyzing the text provided. The operator flag can be set to or or and to control the boolean clauses (defaults to or).

Sets the value controlling how many "should" clauses in the resulting boolean query should match for low frequency terms. It can be an absolute value (2), a percentage (30%) or a combination of both.

const qry = esb.commonTermsQuery('body', 'nelly the elephant as a cartoon')
    .lowFreq(2)
    .highFreq(3)
    .cutoffFrequency(0.001);

Sets the value controlling how many "should" clauses in the resulting boolean query should match for high frequency terms. It can be an absolute value (2), a percentage (30%) or a combination of both.

const qry = esb.commonTermsQuery('body', 'nelly the elephant as a cartoon')
    .lowFreq(2)
    .highFreq(3)
    .cutoffFrequency(0.001);

Enables or disables similarity coordinate scoring of documents commoning the CommonTermsQuery. Default: false.

NOTE: This has been removed in elasticsearch 6.0. If provided, it will be ignored and a deprecation warning will be issued.

Appends given field to the list of fields to search against. Fields can be specified with wildcards.

Individual fields can be boosted with the caret (^) notation. Example - "subject^3"

const qry = esb.queryStringQuery('this AND that OR thus')
    .field('city.*')
    .useDisMax(true);

const qry = esb.simpleQueryStringQuery('foo bar -baz').field('content');

Appends given fields to the list of fields to search against. Fields can be specified with wildcards.

Individual fields can be boosted with the caret (^) notation. Example - [ "subject^3", "message" ]

const qry = esb.queryStringQuery('this AND that')
    .fields(['content', 'name'])

const qry = esb.simpleQueryStringQuery('foo bar baz')
    .fields(['content', 'name.*^5']);

The default operator used if no explicit operator is specified. For example, with a default operator of OR, the query capital of Hungary is translated to capital OR of OR Hungary, and with default operator of AND, the same query is translated to capital AND of AND Hungary. The default value is OR.

By default, wildcards terms in a query string are not analyzed. By setting this value to true, a best effort will be made to analyze those as well.

Sets the lenient parameter which allows to ignore exceptions caused by data-type mismatches such as trying to query a numeric field with a text query string when set to true.

A suffix to append to fields for quoted parts of the query string. This allows to use a field that has a different analysis chain for exact matching.

Perform the query on all fields detected in the mapping that can be queried. Will be used by default when the _all field is disabled and no default_field is specified (either in the index settings or in the request body) and no fields are specified.

The default field for query terms if no prefix field is specified. Defaults to the index.query.default_field index settings, which in turn defaults to _all.

When set, * or ? are allowed as the first character. Defaults to true.

Set to true to enable position increments in result queries. Defaults to true.

Controls the number of terms fuzzy queries will expand to. Defaults to 50.

Sets the fuzziness parameter which is interpreted as a Levenshtein Edit Distance — the number of one character changes that need to be made to one string to make it the same as another string. Defaults to AUTO.

Set the prefix length for fuzzy queries. Default is 0.

Sets the rewrite method. Valid values are:

• constant_score - tries to pick the best constant-score rewrite method based on term and document counts from the query. Synonyms - constant_score_auto, constant_score_filter

• scoring_boolean - translates each term into boolean should and keeps the scores as computed by the query

• constant_score_boolean - same as scoring_boolean, expect no scores are computed.

• constant_score_filter - first creates a private Filter, by visiting each term in sequence and marking all docs for that term

• top_terms_boost_N - first translates each term into boolean should and scores are only computed as the boost using the top N scoring terms. Replace N with an integer value.

• top_terms_N - first translates each term into boolean should and keeps the scores as computed by the query. Only the top N scoring terms are used. Replace N with an integer value.

Default is constant_score.

This is an advanced option, use with care.

Note: The deprecated multi term rewrite parameters constant_score_auto, constant_score_filter (synonyms for constant_score) have been removed in elasticsearch 6.0.

• Error: If the given rewrite method is not valid.

Sets the fuzzy rewrite method. Valid values are:

• constant_score - tries to pick the best constant-score rewrite method based on term and document counts from the query. Synonyms - constant_score_auto, constant_score_filter

• scoring_boolean - translates each term into boolean should and keeps the scores as computed by the query

• constant_score_boolean - same as scoring_boolean, expect no scores are computed.

• constant_score_filter - first creates a private Filter, by visiting each term in sequence and marking all docs for that term

• top_terms_boost_N - first translates each term into boolean should and scores are only computed as the boost using the top N scoring terms. Replace N with an integer value.

• top_terms_N - first translates each term into boolean should and keeps the scores as computed by the query. Only the top N scoring terms are used. Replace N with an integer value.

Default is constant_score.

This is an advanced option, use with care.

Note: The deprecated multi term rewrite parameters constant_score_auto, constant_score_filter (synonyms for constant_score) have been removed in elasticsearch 6.0.

• Error: If the given fuzzy_rewrite method is not valid.

Sets the default slop for phrases. If zero, then exact phrase matches are required. Default value is 0.

Auto generate phrase queries. Defaults to false.

Note: This parameter has been removed in elasticsearch 6.0. If provided, it will be ignored and issue a deprecation warning.

Limit on how many automaton states regexp queries are allowed to create. This protects against too-difficult (e.g. exponentially hard) regexps. Defaults to 10000.

Time Zone to be applied to any range query related to dates.

Whether query text should be split on whitespace prior to analysis. Instead the queryparser would parse around only real operators. Default is false. It is not allowed to set this option to false if auto_generate_phrase_queries is already set to true.

Note: This parameter has been removed in elasticsearch 6.0. If provided, it will be ignored and issue a deprecation warning. The query_string query now splits on operator only.

Should the queries be combined using dis_max (set it to true), or a bool query (set it to false). Defaults to true.

Note: This parameter has been removed in elasticsearch 6.0. If provided, it will be ignored and issue a deprecation warning. The tie_breaker parameter must be used instead.

const qry = esb.queryStringQuery('this AND that OR thus')
    .fields(['content', 'name^5'])
    .useDisMax(true);

When using dis_max, the disjunction max tie breaker. Defaults to 0.

Sets the quote analyzer name used to analyze the query when in quoted text.

If they query string should be escaped or not.

simple_query_string support multiple flags to specify which parsing features should be enabled. It is specified as a |-delimited string.

const qry = esb.simpleQueryStringQuery('foo | bar + baz*')
    .flags('OR|AND|PREFIX');

Sets the field to search on.

Sets the query string.

Override default toJSON to return DSL representation of the term level query class instance.

Allows ASCII case insensitive matching of the value with the indexed field values when set to true.

NOTE: Only available in Elasticsearch v7.10.0+

Sets the field to search on.

Append given value to list of values to run Terms Query with.

Specifies the values to run query for.

• TypeError: If values is not an instance of Array

Convenience method for setting term lookup options. Valid options are index, type, id, pathand routing

The index to fetch the term values from. Defaults to the current index.

Note: The index parameter in the terms filter, used to look up terms in a dedicated index is mandatory in elasticsearch 6.0. Previously, the index defaulted to the index the query was executed on. In 6.0, this index must be explicitly set in the request.

The type to fetch the term values from.

The id of the document to fetch the term values from.

The field specified as path to fetch the actual values for the terms filter.

A custom routing value to be used when retrieving the external terms doc.

Override default toJSON to return DSL representation of the terms query class instance.

Sets the field to search on.

Append given term to set of terms to run Terms Set Query with.

Specifies the terms to run query for.

• TypeError: If terms is not an instance of Array

Controls the number of terms that must match per document.

Sets the script for query. It controls how many terms are required to match in a more dynamic way.

The params.num_terms parameter is available in the script to indicate the number of terms that have been specified.

const qry = esb.termsSetQuery('codes', ['abc', 'def', 'ghi'])
    .minimumShouldMatchScript({
        source: "Math.min(params.num_terms, doc['required_matches'].value)"
    })

Override default toJSON to return DSL representation of the term level query class instance.

• Error: This method cannot be called on RangeQuery

Greater-than or equal to

Less-than or equal to

Greater-than

Less-than

The lower bound. Defaults to start from the first.

The upper bound. Defaults to unbounded.

Should the first from (if set) be inclusive or not. Defaults to true

Should the last to (if set) be inclusive or not. Defaults to true.

Time Zone to be applied to any range query related to dates.

Sets the format expression for parsing the upper and lower bounds. If no format is specified, then it will use the first format specified in the field mapping.

const qry = esb.rangeQuery('born')
    .gte('01/01/2012')
    .lte('2013')
    .format('dd/MM/yyyy||yyyy');

Sets the relationship between Query and indexed data that will be used to determine if a Document should be matched or not.

Override default toJSON to return DSL representation of the range query class instance.

Sets the field to search on.

Sets the rewrite method. Valid values are:

• constant_score - tries to pick the best constant-score rewrite method based on term and document counts from the query. Synonyms - constant_score_auto, constant_score_filter

• scoring_boolean - translates each term into boolean should and keeps the scores as computed by the query

• constant_score_boolean - same as scoring_boolean, expect no scores are computed.

• constant_score_filter - first creates a private Filter, by visiting each term in sequence and marking all docs for that term

• top_terms_boost_N - first translates each term into boolean should and scores are only computed as the boost using the top N scoring terms. Replace N with an integer value.

• top_terms_N - first translates each term into boolean should and keeps the scores as computed by the query. Only the top N scoring terms are used. Replace N with an integer value.

Default is constant_score.

This is an advanced option, use with care.

Note: The deprecated multi term rewrite parameters constant_score_auto, constant_score_filter (synonyms for constant_score) have been removed in elasticsearch 6.0.

• Error: If the given rewrite method is not valid.

Allow case insensitive matching or not (added in 7.10.0). Defaults to false.

const qry = esb.wildcardQuery('user', 'ki*y')
    .caseInsensitive(true);

Sets the rewrite method. Valid values are:

• constant_score - tries to pick the best constant-score rewrite method based on term and document counts from the query. Synonyms - constant_score_auto, constant_score_filter

• scoring_boolean - translates each term into boolean should and keeps the scores as computed by the query

• constant_score_boolean - same as scoring_boolean, expect no scores are computed.

• constant_score_filter - first creates a private Filter, by visiting each term in sequence and marking all docs for that term

• top_terms_boost_N - first translates each term into boolean should and scores are only computed as the boost using the top N scoring terms. Replace N with an integer value.

• top_terms_N - first translates each term into boolean should and keeps the scores as computed by the query. Only the top N scoring terms are used. Replace N with an integer value.

Default is constant_score.

This is an advanced option, use with care.

Note: The deprecated multi term rewrite parameters constant_score_auto, constant_score_filter (synonyms for constant_score) have been removed in elasticsearch 6.0.

• Error: If the given rewrite method is not valid.

Set special flags. Possible flags are ALL (default), ANYSTRING, COMPLEMENT, EMPTY, INTERSECTION, INTERVAL, or NONE.

const qry = esb.regexpQuery('name.first', 's.*y')
    .flags('INTERSECTION|COMPLEMENT|EMPTY');

Allow case insensitive matching or not (added in 7.10.0). Defaults to false.

const qry = esb.regexpQuery('name.first', 's.*y')
    .caseInsensitive(true);

Limit on how many automaton states regexp queries are allowed to create. This protects against too-difficult (e.g. exponentially hard) regexps. Defaults to 10000.

const qry = esb.regexpQuery('name.first', 's.*y')
    .flags('INTERSECTION|COMPLEMENT|EMPTY')
    .maxDeterminizedStates(20000);