honeymoose
/
OpenSearch
mirror of https://github.com/honeymoose/OpenSearch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #18211 from MaineC/docs/add_autosense_to_query_dsl 

Add Autosense annotation for query dsl testing
This commit is contained in:
Isabel Drost-Fromm 2016-05-17 20:55:45 +02:00
parent 978c1e3e36 2d402c732c
commit 5485d5c010
46 changed files with 1420 additions and 854 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
docs/reference/query-dsl/bool-query.asciidoc
View File

@ -81,7 +81,7 @@ all documents where the `status` field contains the term `active`.
This first query assigns a score of `0` to all documents, as no scoring
query has been specified:
[source,json]
[source,js]
---------------------------------
GET _search
{
@ -101,7 +101,7 @@ GET _search
This `bool` query has a `match_all` query, which assigns a score of `1.0` to
all documents.
[source,json]
[source,js]
---------------------------------
GET _search
{
@ -125,7 +125,7 @@ This `constant_score` query behaves in exactly the same way as the second exampl
The `constant_score` query assigns a score of `1.0` to all documents matched
by the filter.
[source,json]
[source,js]
---------------------------------
GET _search
{

4
docs/reference/query-dsl/boosting-query.asciidoc
View File

@ -8,7 +8,9 @@ overall score.
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"boosting" : {
"positive" : {
"term" : {
@ -23,4 +25,6 @@ overall score.
"negative_boost" : 0.2
}
}
}
--------------------------------------------------
// CONSOLE

44
docs/reference/query-dsl/common-terms-query.asciidoc
View File

@ -70,7 +70,9 @@ In this example, words that have a document frequency greater than 0.1%
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"common": {
"body": {
"query": "this is bonsai cool",
@ -78,7 +80,9 @@ In this example, words that have a document frequency greater than 0.1%
}
}
}
}
--------------------------------------------------
// CONSOLE
The number of terms which should match can be controlled with the
<<query-dsl-minimum-should-match,`minimum_should_match`>>
@ -90,7 +94,9 @@ all terms required:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"common": {
"body": {
"query": "nelly the elephant as a cartoon",
@ -99,13 +105,17 @@ all terms required:
}
}
}
}
--------------------------------------------------
// CONSOLE
which is roughly equivalent to:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool": {
"must": [
{ "term": { "body": "nelly"}},
@ -113,13 +123,15 @@ which is roughly equivalent to:
{ "term": { "body": "cartoon"}}
],
"should": [
{ "term": { "body": "the"}}
{ "term": { "body": "as"}}
{ "term": { "body": "the"}},
{ "term": { "body": "as"}},
{ "term": { "body": "a"}}
]
}
}
}
--------------------------------------------------
// CONSOLE
Alternatively use
<<query-dsl-minimum-should-match,`minimum_should_match`>>
@ -128,7 +140,9 @@ must be present, for instance:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"common": {
"body": {
"query": "nelly the elephant as a cartoon",
@ -137,13 +151,17 @@ must be present, for instance:
}
}
}
}
--------------------------------------------------
// CONSOLE
which is roughly equivalent to:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool": {
"must": {
"bool": {
@ -156,13 +174,15 @@ which is roughly equivalent to:
}
},
"should": [
{ "term": { "body": "the"}}
{ "term": { "body": "as"}}
{ "term": { "body": "the"}},
{ "term": { "body": "as"}},
{ "term": { "body": "a"}}
]
}
}
}
--------------------------------------------------
// CONSOLE
minimum_should_match
@ -174,7 +194,9 @@ additional parameters (note the change in structure):
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"common": {
"body": {
"query": "nelly the elephant not as a cartoon",
@ -186,13 +208,17 @@ additional parameters (note the change in structure):
}
}
}
}
--------------------------------------------------
// CONSOLE
which is roughly equivalent to:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool": {
"must": {
"bool": {
@ -217,7 +243,9 @@ which is roughly equivalent to:
}
}
}
}
--------------------------------------------------
// CONSOLE
In this case it means the high frequency terms have only an impact on
relevance when there are at least three of them. But the most
@ -227,7 +255,9 @@ for high frequency terms is when there are only high frequency terms:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"common": {
"body": {
"query": "how not to be",
@ -239,13 +269,17 @@ for high frequency terms is when there are only high frequency terms:
}
}
}
}
--------------------------------------------------
// CONSOLE
which is roughly equivalent to:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool": {
"should": [
{ "term": { "body": "how"}},
@ -256,7 +290,9 @@ which is roughly equivalent to:
"minimum_should_match": "3<50%"
}
}
}
--------------------------------------------------
// CONSOLE
The high frequency generated query is then slightly less restrictive
than with an `AND`.

4
docs/reference/query-dsl/constant-score-query.asciidoc
View File

@ -7,7 +7,9 @@ filter. Maps to Lucene `ConstantScoreQuery`.
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"constant_score" : {
"filter" : {
"term" : { "user" : "kimchy"}
@ -15,4 +17,6 @@ filter. Maps to Lucene `ConstantScoreQuery`.
"boost" : 1.2
}
}
}
--------------------------------------------------
// CONSOLE

4
docs/reference/query-dsl/dis-max-query.asciidoc
View File

@ -27,7 +27,9 @@ This query maps to Lucene `DisjunctionMaxQuery`.
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"dis_max" : {
"tie_breaker" : 0.7,
"boost" : 1.2,
@ -41,4 +43,6 @@ This query maps to Lucene `DisjunctionMaxQuery`.
]
}
}
}
--------------------------------------------------
// CONSOLE

10
docs/reference/query-dsl/exists-query.asciidoc
View File

@ -5,10 +5,14 @@ Returns documents that have at least one non-`null` value in the original field:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"exists" : { "field" : "user" }
}
}
--------------------------------------------------
// CONSOLE
For instance, these documents would all match the above query:
@ -77,6 +81,9 @@ clause as follows:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool": {
"must_not": {
"exists": {
@ -84,7 +91,10 @@ clause as follows:
}
}
}
}
}
--------------------------------------------------
// CONSOLE
This query returns documents that have no value in the user field.

44
docs/reference/query-dsl/function-score-query.asciidoc
View File

@ -14,13 +14,20 @@ by the query.
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"function_score": {
"query": {},
"boost": "boost for the whole query",
"FUNCTION": {}, <1>
"boost_mode":"(multiply|replace|...)"
"boost": "5",
"random_score": {}, <1>
"boost_mode":"multiply"
}
}
}
--------------------------------------------------
// CONSOLE
<1> See <<score-functions>> for a list of supported functions.
Furthermore, several functions can be combined. In this case one can
@ -29,30 +36,35 @@ given filtering query
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"function_score": {
"query": {},
"boost": "boost for the whole query",
"boost": "5", <1>
"functions": [
{
"filter": {},
"FUNCTION": {}, <1>
"weight": number
},
{
"FUNCTION": {} <1>
"random_score": {}, <2>
"weight": 23
},
{
"filter": {},
"weight": number
"weight": 42
}
],
"max_boost": number,
"score_mode": "(multiply|max|...)",
"boost_mode": "(multiply|replace|...)",
"min_score" : number
"max_boost": 42,
"score_mode": "max",
"boost_mode": "multiply",
"min_score" : 42
}
}
}
--------------------------------------------------
<1> See <<score-functions>> for a list of supported functions.
// CONSOLE
<1> Boost for the whole query.
<2> See <<score-functions>> for a list of supported functions.
NOTE: The scores produced by the filtering query of each function do not matter.
@ -459,7 +471,7 @@ the request would look like this:
[source,js]
--------------------------------------------------
GET _search
GET /_search
{
"query": {
"function_score": {

9
docs/reference/query-dsl/fuzzy-query.asciidoc
View File

@ -16,16 +16,22 @@ Here is a simple example:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"fuzzy" : { "user" : "ki" }
}
}
--------------------------------------------------
// CONSOLE
Or with more advanced settings:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"fuzzy" : {
"user" : {
"value" : "ki",
@ -36,7 +42,9 @@ Or with more advanced settings:
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
===== Parameters
@ -62,3 +70,4 @@ WARNING: This query can be very heavy if `prefix_length` is set to `0` and if
`max_expansions` is set to a high number. It could result in every term in the
index being examined!

48
docs/reference/query-dsl/geo-bounding-box-query.asciidoc
View File

@ -6,6 +6,24 @@ bounding box. Assuming the following indexed document:
[source,js]
--------------------------------------------------
PUT /my_locations
{
"mappings": {
"location": {
"properties": {
"pin": {
"properties": {
"location": {
"type": "geo_point"
}
}
}
}
}
}
}
PUT /my_locations/location/1
{
"pin" : {
"location" : {
@ -15,13 +33,17 @@ bounding box. Assuming the following indexed document:
}
}
--------------------------------------------------
// CONSOLE
// TESTSETUP
Then the following simple query can be executed with a
`geo_bounding_box` filter:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool" : {
"must" : {
"match_all" : {}
@ -42,7 +64,9 @@ Then the following simple query can be executed with a
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
==== Query Options
@ -75,7 +99,9 @@ representation of the geo point, the filter can accept it as well:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool" : {
"must" : {
"match_all" : {}
@ -96,7 +122,9 @@ representation of the geo point, the filter can accept it as well:
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
===== Lat Lon As Array
@ -106,7 +134,9 @@ conform with http://geojson.org/[GeoJSON].
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool" : {
"must" : {
"match_all" : {}
@ -121,7 +151,9 @@ conform with http://geojson.org/[GeoJSON].
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
===== Lat Lon As String
@ -130,7 +162,9 @@ Format in `lat,lon`.
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool" : {
"must" : {
"match_all" : {}
@ -145,14 +179,18 @@ Format in `lat,lon`.
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
===== Geohash
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool" : {
"must" : {
"match_all" : {}
@ -167,7 +205,9 @@ Format in `lat,lon`.
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
==== Vertices
@ -181,7 +221,9 @@ values separately.
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool" : {
"must" : {
"match_all" : {}
@ -198,7 +240,9 @@ values separately.
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
@ -227,7 +271,9 @@ are not supported. Here is an example:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool" : {
"must" : {
"match_all" : {}
@ -249,7 +295,9 @@ are not supported. Here is an example:
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
==== Ignore Unmapped

45
docs/reference/query-dsl/geo-distance-query.asciidoc
View File

@ -2,10 +2,29 @@
=== Geo Distance Query
Filters documents that include only hits that exists within a specific
distance from a geo point. Assuming the following indexed json:
distance from a geo point. Assuming the following mapping and indexed
document:
[source,js]
--------------------------------------------------
PUT /my_locations
{
"mappings": {
"location": {
"properties": {
"pin": {
"properties": {
"location": {
"type": "geo_point"
}
}
}
}
}
}
}
PUT /my_locations/location/1
{
"pin" : {
"location" : {
@ -15,13 +34,18 @@ distance from a geo point. Assuming the following indexed json:
}
}
--------------------------------------------------
// CONSOLE
// TESTSETUP
Then the following simple query can be executed with a `geo_distance`
filter:
[source,js]
--------------------------------------------------
GET /my_locations/location/_search
{
"query": {
"bool" : {
"must" : {
"match_all" : {}
@ -37,7 +61,9 @@ filter:
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
==== Accepted Formats
@ -50,7 +76,9 @@ representation of the geo point, the filter can accept it as well:
[source,js]
--------------------------------------------------
GET /my_locations/location/_search
{
"query": {
"bool" : {
"must" : {
"match_all" : {}
@ -66,7 +94,9 @@ representation of the geo point, the filter can accept it as well:
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
===== Lat Lon As Array
@ -76,7 +106,9 @@ conform with http://geojson.org/[GeoJSON].
[source,js]
--------------------------------------------------
GET /my_locations/location/_search
{
"query": {
"bool" : {
"must" : {
"match_all" : {}
@ -89,7 +121,10 @@ conform with http://geojson.org/[GeoJSON].
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
===== Lat Lon As String
@ -98,7 +133,9 @@ Format in `lat,lon`.
[source,js]
--------------------------------------------------
GET /my_locations/location/_search
{
"query": {
"bool" : {
"must" : {
"match_all" : {}
@ -111,14 +148,18 @@ Format in `lat,lon`.
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
===== Geohash
[source,js]
--------------------------------------------------
GET /my_locations/location/_search
{
"query": {
"bool" : {
"must" : {
"match_all" : {}
@ -131,7 +172,9 @@ Format in `lat,lon`.
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
==== Options

4
docs/reference/query-dsl/geo-distance-range-query.asciidoc
View File

@ -5,7 +5,9 @@ Filters documents that exists within a range from a specific point:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool" : {
"must" : {
"match_all" : {}
@ -22,7 +24,9 @@ Filters documents that exists within a range from a specific point:
}
}
}
}
--------------------------------------------------
// CONSOLE
Supports the same point location parameter and query options as the
<<query-dsl-geo-distance-query,geo_distance>>

18
docs/reference/query-dsl/geo-polygon-query.asciidoc
View File

@ -6,9 +6,11 @@ points. Here is an example:
[source,js]
--------------------------------------------------
GET /_search
{
"bool" : {
"query": {
"bool" : {
"must" : {
"match_all" : {}
},
"filter" : {
@ -24,7 +26,9 @@ points. Here is an example:
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
==== Query Options
@ -53,7 +57,9 @@ conform with http://geojson.org/[GeoJSON].
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool" : {
"must" : {
"match_all" : {}
@ -71,7 +77,9 @@ conform with http://geojson.org/[GeoJSON].
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
===== Lat Lon as String
@ -80,7 +88,9 @@ Format in `lat,lon`.
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool" : {
"must" : {
"match_all" : {}
@ -98,14 +108,18 @@ Format in `lat,lon`.
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
===== Geohash
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool" : {
"must" : {
"match_all" : {}
@ -123,7 +137,9 @@ Format in `lat,lon`.
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
==== geo_point Type

6
docs/reference/query-dsl/geo-shape-query.asciidoc
View File

@ -38,6 +38,7 @@ The following query will find the point using the Elasticsearch's
[source,js]
--------------------------------------------------
GET /_search
{
"query":{
"bool": {
@ -59,6 +60,7 @@ The following query will find the point using the Elasticsearch's
}
}
--------------------------------------------------
// CONSOLE
==== Pre-Indexed Shape
@ -81,7 +83,9 @@ shape:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool": {
"must": {
"match_all": {}
@ -100,7 +104,9 @@ shape:
}
}
}
}
--------------------------------------------------
// CONSOLE
==== Spatial Relations

7
docs/reference/query-dsl/geohash-cell-query.asciidoc
View File

@ -13,6 +13,7 @@ setting the `geohash_prefix` option:
[source,js]
--------------------------------------------------
PUT /my_index
{
"mappings" : {
"location": {
@ -28,6 +29,8 @@ setting the `geohash_prefix` option:
}
}
--------------------------------------------------
// CONSOLE
// TESTSETUP
The geohash cell can defined by all formats of `geo_points`. If such a cell is
defined by a latitude and longitude pair the size of the cell needs to be
@ -42,7 +45,9 @@ next to the given cell.
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool" : {
"must" : {
"match_all" : {}
@ -59,7 +64,9 @@ next to the given cell.
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
==== Ignore Unmapped

12
docs/reference/query-dsl/has-child-query.asciidoc
View File

@ -7,7 +7,9 @@ an example:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"has_child" : {
"type" : "blog_tag",
"query" : {
@ -17,7 +19,9 @@ an example:
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
==== Scoring capabilities
@ -32,7 +36,9 @@ inside the `has_child` query:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"has_child" : {
"type" : "blog_tag",
"score_mode" : "min",
@ -43,7 +49,9 @@ inside the `has_child` query:
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
==== Min/Max Children
@ -54,7 +62,9 @@ a match:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"has_child" : {
"type" : "blog_tag",
"score_mode" : "min",
@ -67,7 +77,9 @@ a match:
}
}
}
}
--------------------------------------------------
// CONSOLE
<1> Both `min_children` and `max_children` are optional.
The `min_children` and `max_children` parameters can be combined with

8
docs/reference/query-dsl/has-parent-query.asciidoc
View File

@ -9,7 +9,9 @@ in the same manner as the `has_child` query.
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"has_parent" : {
"parent_type" : "blog",
"query" : {
@ -19,7 +21,9 @@ in the same manner as the `has_child` query.
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
==== Scoring capabilities
@ -34,7 +38,9 @@ matching parent document. The score mode can be specified with the
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"has_parent" : {
"parent_type" : "blog",
"score" : true,
@ -45,7 +51,9 @@ matching parent document. The score mode can be specified with the
}
}
}
}
--------------------------------------------------
// CONSOLE
[float]
==== Ignore Unmapped

4
docs/reference/query-dsl/ids-query.asciidoc
View File

@ -6,13 +6,17 @@ uses the <<mapping-uid-field,_uid>> field.
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"ids" : {
"type" : "my_type",
"values" : ["1", "4", "100"]
}
}
}
--------------------------------------------------
// CONSOLE
The `type` is optional and can be omitted, and can also accept an array
of values. If no type is specified, all types defined in the index mapping are tried.

10
docs/reference/query-dsl/indices-query.asciidoc
View File

@ -9,18 +9,18 @@ on the list, the alternative `no_match_query` is executed.
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"indices" : {
"indices" : ["index1", "index2"],
"query" : {
"term" : { "tag" : "wow" }
},
"no_match_query" : {
"term" : { "tag" : "kow" }
"query" : { "term" : { "tag" : "wow" } },
"no_match_query" : { "term" : { "tag" : "kow" } }
}
}
}
--------------------------------------------------
// CONSOLE
You can use the `index` field to provide a single index.

24
docs/reference/query-dsl/match-all-query.asciidoc
View File

@ -6,15 +6,27 @@ of `1.0`.
[source,js]
--------------------------------------------------
{ "match_all": {} }
GET /_search
{
"query": {
"match_all": {}
}
}
--------------------------------------------------
// CONSOLE
The `_score` can be changed with the `boost` parameter:
[source,js]
--------------------------------------------------
{ "match_all": { "boost" : 1.2 }}
GET /_search
{
"query": {
"match_all": { "boost" : 1.2 }
}
}
--------------------------------------------------
// CONSOLE
[[query-dsl-match-none-query]]
[float]
@ -24,5 +36,11 @@ This is the inverse of the `match_all` query, which matches no documents.
[source,js]
--------------------------------------------------
{ "match_none": {} }
GET /_search
{
"query": {
"match_none": {}
}
}
--------------------------------------------------
// CONSOLE

8
docs/reference/query-dsl/match-phrase-prefix-query.asciidoc
View File

@ -6,12 +6,16 @@ allows for prefix matches on the last term in the text. For example:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"match_phrase_prefix" : {
"message" : "quick brown f"
}
}
}
--------------------------------------------------
// CONSOLE
It accepts the same parameters as the phrase type. In addition, it also
accepts a `max_expansions` parameter (default `50`) that can control to how
@ -21,7 +25,9 @@ example:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"match_phrase_prefix" : {
"message" : {
"query" : "quick brown f",
@ -29,7 +35,9 @@ example:
}
}
}
}
--------------------------------------------------
// CONSOLE
[IMPORTANT]
===================================================

8
docs/reference/query-dsl/match-phrase-query.asciidoc
View File

@ -6,12 +6,16 @@ out of the analyzed text. For example:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"match_phrase" : {
"message" : "this is a test"
}
}
}
--------------------------------------------------
// CONSOLE
A phrase query matches terms up to a configurable `slop`
(which defaults to 0) in any order. Transposed terms have a slop of 2.
@ -22,7 +26,9 @@ definition, or the default search analyzer, for example:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"match_phrase" : {
"message" : {
"query" : "this is a test",
@ -30,4 +36,6 @@ definition, or the default search analyzer, for example:
}
}
}
}
--------------------------------------------------
// CONSOLE

17
docs/reference/query-dsl/match-query.asciidoc
View File

@ -7,12 +7,16 @@ them, and constructs a query. For example:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"match" : {
"message" : "this is a test"
}
}
}
--------------------------------------------------
// CONSOLE
Note, `message` is the name of a field, you can substitute the name of
any field (including `_all`) instead.
@ -57,7 +61,9 @@ change in structure, `message` is the field name):
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"match" : {
"message" : {
"query" : "this is a test",
@ -65,7 +71,9 @@ change in structure, `message` is the field name):
}
}
}
}
--------------------------------------------------
// CONSOLE
[[query-dsl-match-query-zero]]
===== Zero terms query
@ -76,7 +84,9 @@ change that the `zero_terms_query` option can be used, which accepts
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"match" : {
"message" : {
"query" : "to be or not to be",
@ -85,7 +95,9 @@ change that the `zero_terms_query` option can be used, which accepts
}
}
}
}
--------------------------------------------------
// CONSOLE
[[query-dsl-match-query-cutoff]]
===== Cutoff frequency
@ -113,7 +125,9 @@ Here is an example showing a query composed of stopwords exclusively:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"match" : {
"message" : {
"query" : "to be or not to be",
@ -121,8 +135,9 @@ Here is an example showing a query composed of stopwords exclusively:
}
}
}
}
--------------------------------------------------
// CONSOLE
IMPORTANT: The `cutoff_frequency` option operates on a per-shard-level. This means
that when trying it out on test indexes with low document numbers you

16
docs/reference/query-dsl/mlt-query.asciidoc
View File

@ -15,7 +15,9 @@ fields, limiting the number of selected terms to 12.
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"more_like_this" : {
"fields" : ["title", "description"],
"like" : "Once upon a time",
@ -23,7 +25,9 @@ fields, limiting the number of selected terms to 12.
"max_query_terms" : 12
}
}
}
--------------------------------------------------
// CONSOLE
A more complicated use case consists of mixing texts with documents already
existing in the index. In this case, the syntax to specify a document is
@ -31,7 +35,9 @@ similar to the one used in the <<docs-multi-get,Multi GET API>>.
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"more_like_this" : {
"fields" : ["title", "description"],
"like" : [
@ -51,7 +57,9 @@ similar to the one used in the <<docs-multi-get,Multi GET API>>.
"max_query_terms" : 12
}
}
}
--------------------------------------------------
// CONSOLE
Finally, users can mix some texts, a chosen set of documents but also provide
documents not necessarily present in the index. To provide documents not
@ -59,7 +67,9 @@ present in the index, the syntax is similar to <<docs-termvectors-artificial-doc
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"more_like_this" : {
"fields" : ["name.first", "name.last"],
"like" : [
@ -84,7 +94,9 @@ present in the index, the syntax is similar to <<docs-termvectors-artificial-doc
"max_query_terms" : 12
}
}
}
--------------------------------------------------
// CONSOLE
==== How it Works
@ -111,7 +123,8 @@ default, but there will be no speed up on analysis for these fields.
[source,js]
--------------------------------------------------
curl -s -XPUT 'http://localhost:9200/imdb/' -d '{
PUT /imdb
{
"mappings": {
"movies": {
"properties": {
@ -137,6 +150,7 @@ curl -s -XPUT 'http://localhost:9200/imdb/' -d '{
}
}
--------------------------------------------------
// CONSOLE
==== Parameters

60
docs/reference/query-dsl/multi-match-query.asciidoc
View File

@ -6,13 +6,17 @@ to allow multi-field queries:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"multi_match" : {
"query": "this is a test", <1>
"fields": [ "subject", "message" ] <2>
}
}
}
--------------------------------------------------
// CONSOLE
<1> The query string.
<2> The fields to be queried.
@ -23,26 +27,35 @@ Fields can be specified with wildcards, eg:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"multi_match" : {
"query": "Will Smith",
"fields": [ "title", "*_name" ] <1>
}
}
}
--------------------------------------------------
// CONSOLE
<1> Query the `title`, `first_name` and `last_name` fields.
Individual fields can be boosted with the caret (`^`) notation:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"multi_match" : {
"query" : "this is a test",
"fields" : [ "subject^3", "message" ] <1>
}
}
}
--------------------------------------------------
// CONSOLE
<1> The `subject` field is three times as important as the `message` field.
[[multi-match-types]]
@ -82,7 +95,9 @@ find the single best matching field. For instance, this query:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"multi_match" : {
"query": "brown fox",
"type": "best_fields",
@ -90,13 +105,17 @@ find the single best matching field. For instance, this query:
"tie_breaker": 0.3
}
}
}
--------------------------------------------------
// CONSOLE
would be executed as:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"dis_max": {
"queries": [
{ "match": { "subject": "brown fox" }},
@ -105,7 +124,9 @@ would be executed as:
"tie_breaker": 0.3
}
}
}
--------------------------------------------------
// CONSOLE
Normally the `best_fields` type uses the score of the *single* best matching
field, but if `tie_breaker` is specified, then it calculates the score as
@ -132,7 +153,9 @@ Take this query for example:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"multi_match" : {
"query": "Will Smith",
"type": "best_fields",
@ -140,7 +163,10 @@ Take this query for example:
"operator": "and" <1>
}
}
}
--------------------------------------------------
// CONSOLE
<1> All terms must be present.
This query is executed as:
@ -170,20 +196,26 @@ This query:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"multi_match" : {
"query": "quick brown fox",
"type": "most_fields",
"fields": [ "title", "title.original", "title.shingles" ]
}
}
}
--------------------------------------------------
// CONSOLE
would be executed as:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool": {
"should": [
{ "match": { "title": "quick brown fox" }},
@ -192,7 +224,9 @@ would be executed as:
]
}
}
}
--------------------------------------------------
// CONSOLE
The score from each `match` clause is added together, then divided by the
number of `match` clauses.
@ -212,20 +246,26 @@ but they use a `match_phrase` or `match_phrase_prefix` query instead of a
This query:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"multi_match" : {
"query": "quick brown f",
"type": "phrase_prefix",
"fields": [ "subject", "message" ]
}
}
}
--------------------------------------------------
// CONSOLE
would be executed as:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"dis_max": {
"queries": [
{ "match_phrase_prefix": { "subject": "quick brown f" }},
@ -233,7 +273,9 @@ would be executed as:
]
}
}
}
--------------------------------------------------
// CONSOLE
Also, accepts `analyzer`, `boost`, `slop` and `zero_terms_query` as explained
in <<query-dsl-match-query>>. Type `phrase_prefix` additionally accepts
@ -288,7 +330,9 @@ A query like:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"multi_match" : {
"query": "Will Smith",
"type": "cross_fields",
@ -296,7 +340,9 @@ A query like:
"operator": "and"
}
}
}
--------------------------------------------------
// CONSOLE
is executed as:
@ -344,7 +390,9 @@ both use an `edge_ngram` analyzer, this query:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"multi_match" : {
"query": "Jon",
"type": "cross_fields",
@ -354,7 +402,9 @@ both use an `edge_ngram` analyzer, this query:
]
}
}
}
--------------------------------------------------
// CONSOLE
would be executed as:
@ -379,7 +429,9 @@ parameter to just one of them:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"bool": {
"should": [
{
@ -400,7 +452,10 @@ parameter to just one of them:
]
}
}
}
--------------------------------------------------
// CONSOLE
<1> Either `will` or `smith` must be present in either of the `first`
or `last` fields
@ -409,7 +464,9 @@ parameter in the query.
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"multi_match" : {
"query": "Jon",
"type": "cross_fields",
@ -417,7 +474,10 @@ parameter in the query.
"fields": [ "first", "last", "*.edge" ]
}
}
}
--------------------------------------------------
// CONSOLE
<1> Use the `standard` analyzer for all fields.
which will be executed as:

17
docs/reference/query-dsl/nested-query.asciidoc
View File

@ -10,7 +10,9 @@ will work with:
[source,js]
--------------------------------------------------
PUT /my_index
{
"mappings": {
"type1" : {
"properties" : {
"obj1" : {
@ -19,31 +21,34 @@ will work with:
}
}
}
}
--------------------------------------------------
// CONSOLE
// TESTSETUP
And here is a sample nested query usage:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"nested" : {
"path" : "obj1",
"score_mode" : "avg",
"query" : {
"bool" : {
"must" : [
{
"match" : {"obj1.name" : "blue"}
},
{
"range" : {"obj1.count" : {"gt" : 5}}
}
{ "match" : {"obj1.name" : "blue"} },
{ "range" : {"obj1.count" : {"gt" : 5}} }
]
}
}
}
}
}
--------------------------------------------------
// CONSOLE
The query `path` points to the nested object path, and the `query`
includes the query that will run on the nested docs matching the

39
docs/reference/query-dsl/parent-id-query.asciidoc
View File

@ -3,17 +3,48 @@
added[5.0.0]
The `parent_id` query can be used to find child documents which belong to a particular parent:
The `parent_id` query can be used to find child documents which belong to a
particular parent. Given the following mapping definition:
[source,js]
--------------------------------------------------
PUT /my_index
{
"mappings": {
"blog_post": {
"properties": {
"name": {
"type": "keyword"
}
}
},
"blog_tag": {
"_parent": {
"type": "blog_post"
},
"_routing": {
"required": true
}
}
}
}
--------------------------------------------------
// CONSOLE
// TESTSETUP
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"parent_id" : {
"type" : "blog_tag",
"id" : "1"
}
}
}
--------------------------------------------------
// CONSOLE
The above is functionally equivalent to using the following
<<query-dsl-has-parent-query, `has_parent`>> query, but performs
@ -21,9 +52,11 @@ better as it does not need to do a join:
[source,js]
--------------------------------------------------
GET /my_index/_search
{
"query": {
"has_parent": {
"type": "blog",
"type": "blog_post",
"query": {
"term": {
"_id": "1"
@ -31,7 +64,9 @@ better as it does not need to do a join:
}
}
}
}
--------------------------------------------------
// CONSOLE
==== Parameters

50
docs/reference/query-dsl/percolate-query.asciidoc
View File

@ -13,7 +13,7 @@ Create an index with two mappings:
[source,js]
--------------------------------------------------
curl -XPUT "http://localhost:9200/my-index" -d'
PUT /my-index
{
"mappings": {
"doctype": {
@ -31,8 +31,9 @@ curl -XPUT "http://localhost:9200/my-index" -d'
}
}
}
}'
}
--------------------------------------------------
// CONSOLE
The `doctype` mapping is the mapping used to preprocess
the document defined in the `percolator` query before it
@ -50,20 +51,24 @@ Register a query in the percolator:
[source,js]
--------------------------------------------------
curl -XPUT 'localhost:9200/my-index/queries/1' -d '{
PUT /my-index/queries/1
{
"query" : {
"match" : {
"message" : "bonsai tree"
}
}
}'
}
--------------------------------------------------
// CONSOLE
// TEST[continued]
Match a document to the registered percolator queries:
[source,js]
--------------------------------------------------
curl -XGET 'localhost:9200/my-index/_search' -d '{
GET /my-index/_search
{
"query" : {
"percolate" : {
"field" : "query",
@ -73,8 +78,10 @@ curl -XGET 'localhost:9200/my-index/_search' -d '{
}
}
}
}'
}
--------------------------------------------------
// CONSOLE
// TEST[continued]
The above request will yield the following response:
@ -151,12 +158,13 @@ Index the document we want to percolate:
[source,js]
--------------------------------------------------
curl -XPUT "http://localhost:9200/my-index/message/1" -d'
PUT /my-index/message/1
{
"message" : "A new bonsai tree in the office"
}'
}
--------------------------------------------------
// CONSOLE
// TEST[continued]
Index response:
[source,js]
@ -179,7 +187,7 @@ Percolating an existing document, using the index response as basis to build to
[source,js]
--------------------------------------------------
curl -XGET "http://localhost:9200/my-index/_search" -d'
GET /my-index/_search
{
"query" : {
"percolate" : {
@ -191,8 +199,10 @@ curl -XGET "http://localhost:9200/my-index/_search" -d'
"version" : 1 <1>
}
}
}'
}
--------------------------------------------------
// CONSOLE
// TEST[continued]
<1> The version is optional, but useful in certain cases. We can then ensure that we are try to percolate
the document we just have indexed. A change may be made after we have indexed, and if that is the
@ -216,35 +226,39 @@ Save a query:
[source,js]
--------------------------------------------------
curl -XPUT "http://localhost:9200/my-index/queries/1" -d'
PUT /my-index/queries/1
{
"query" : {
"match" : {
"message" : "brown fox"
}
}
}'
}
--------------------------------------------------
// CONSOLE
// TEST[continued]
Save another query:
[source,js]
--------------------------------------------------
curl -XPUT "http://localhost:9200/my-index/queries/2" -d'
PUT /my-index/queries/2
{
"query" : {
"match" : {
"message" : "lazy dog"
}
}
}'
}
--------------------------------------------------
// CONSOLE
// TEST[continued]
Execute a search request with the `percolate` query and highlighting enabled:
[source,js]
--------------------------------------------------
curl -XGET "http://localhost:9200/my-index/_search" -d'
GET /my-index/_search
{
"query" : {
"percolate" : {
@ -260,8 +274,10 @@ curl -XGET "http://localhost:9200/my-index/_search" -d'
"message": {}
}
}
}'
}
--------------------------------------------------
// CONSOLE
// TEST[continued]
This will yield the following response.

15
docs/reference/query-dsl/prefix-query.asciidoc
View File

@ -8,28 +8,37 @@ that starts with `ki`:
[source,js]
--------------------------------------------------
{
GET /_search
{ "query": {
"prefix" : { "user" : "ki" }
}
}
--------------------------------------------------
// CONSOLE
A boost can also be associated with the query:
[source,js]
--------------------------------------------------
{
GET /_search
{ "query": {
"prefix" : { "user" : { "value" : "ki", "boost" : 2.0 } }
}
}
--------------------------------------------------
// CONSOLE
Or :
[source,js]
--------------------------------------------------
{
GET /_search
{ "query": {
"prefix" : { "user" : { "prefix" : "ki", "boost" : 2.0 } }
}
}
--------------------------------------------------
// CONSOLE
This multi term query allows you to control how it gets rewritten using the
<<query-dsl-multi-term-rewrite,rewrite>>

24
docs/reference/query-dsl/query-string-query.asciidoc
View File

@ -6,13 +6,17 @@ an example:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"query_string" : {
"default_field" : "content",
"query" : "this AND that OR thus"
}
}
}
--------------------------------------------------
// CONSOLE
The `query_string` top level parameters include:
@ -113,25 +117,33 @@ For example, the following query
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"query_string" : {
"fields" : ["content", "name"],
"query" : "this AND that"
}
}
}
--------------------------------------------------
// CONSOLE
matches the same words as
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"query_string": {
"query": "(content:this OR name:this) AND (content:that OR name:that)"
}
}
}
--------------------------------------------------
// CONSOLE
Since several queries are generated from the individual search terms,
combining them can be automatically done using either a `dis_max` query or a
@ -140,14 +152,18 @@ notation):
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"query_string" : {
"fields" : ["content", "name^5"],
"query" : "this AND that OR thus",
"use_dis_max" : true
}
}
}
--------------------------------------------------
// CONSOLE
Simple wildcard can also be used to search "within" specific inner
elements of the document. For example, if we have a `city` object with
@ -156,14 +172,18 @@ search on all "city" fields:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"query_string" : {
"fields" : ["city.*"],
"query" : "this AND that OR thus",
"use_dis_max" : true
}
}
}
--------------------------------------------------
// CONSOLE
Another option is to provide the wildcard fields search in the query
string itself (properly escaping the `*` sign), for example:
@ -188,13 +208,17 @@ introduced fields included). For example:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"query_string" : {
"fields" : ["content", "name.*^5"],
"query" : "this AND that OR thus",
"use_dis_max" : true
}
}
}
--------------------------------------------------
// CONSOLE
include::query-string-syntax.asciidoc[]

3
docs/reference/query-dsl/query_filter_context.asciidoc
View File

@ -47,7 +47,7 @@ conditions are met:
[source,js]
------------------------------------
GET _search
GET /_search
{
"query": { <1>
"bool": { <2>
@ -63,6 +63,7 @@ GET _search
}
}
------------------------------------
// CONSOLE
<1> The `query` parameter indicates query context.
<2> The `bool` and two `match` clauses are used in query context,
which means that they are used to score how well each document

16
docs/reference/query-dsl/range-query.asciidoc
View File

@ -9,7 +9,9 @@ a `NumericRangeQuery`. The following example returns all documents where
[source,js]
--------------------------------------------------
GET _search
{
"query": {
"range" : {
"age" : {
"gte" : 10,
@ -18,7 +20,9 @@ a `NumericRangeQuery`. The following example returns all documents where
}
}
}
}
--------------------------------------------------
// CONSOLE
The `range` query accepts the following parameters:
@ -38,7 +42,9 @@ specified using <<date-math>>:
[source,js]
--------------------------------------------------
GET _search
{
"query": {
"range" : {
"date" : {
"gte" : "now-1d/d",
@ -46,7 +52,9 @@ specified using <<date-math>>:
}
}
}
}
--------------------------------------------------
// CONSOLE
===== Date math and rounding
@ -86,7 +94,9 @@ passing the `format` parameter to the `range` query:
[source,js]
--------------------------------------------------
GET _search
{
"query": {
"range" : {
"born" : {
"gte": "01/01/2012",
@ -95,7 +105,9 @@ passing the `format` parameter to the `range` query:
}
}
}
}
--------------------------------------------------
// CONSOLE
===== Time zone in range queries
@ -105,7 +117,9 @@ accepts it), or it can be specified as the `time_zone` parameter:
[source,js]
--------------------------------------------------
GET _search
{
"query": {
"range" : {
"timestamp" : {
"gte": "2015-01-01 00:00:00", <1>
@ -114,6 +128,8 @@ accepts it), or it can be specified as the `time_zone` parameter:
}
}
}
}
--------------------------------------------------
// CONSOLE
<1> This date will be converted to `2014-12-31T23:00:00 UTC`.
<2> `now` is not affected by the `time_zone` parameter (dates must be stored as UTC).

17
docs/reference/query-dsl/regexp-query.asciidoc
View File

@ -15,18 +15,24 @@ matchers like `.*?+` will mostly lower performance.
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"regexp":{
"name.first": "s.*y"
}
}
}
--------------------------------------------------
// CONSOLE
Boosting is also supported
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"regexp":{
"name.first":{
"value":"s.*y",
@ -34,13 +40,17 @@ Boosting is also supported
}
}
}
}
--------------------------------------------------
// CONSOLE
You can also use special flags
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"regexp":{
"name.first": {
"value": "s.*y",
@ -48,7 +58,9 @@ You can also use special flags
}
}
}
}
--------------------------------------------------
// CONSOLE
Possible flags are `ALL` (default), `ANYSTRING`, `COMPLEMENT`,
`EMPTY`, `INTERSECTION`, `INTERVAL`, or `NONE`. Please check the
@ -64,7 +76,9 @@ this limit to allow more complex regular expressions to execute.
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"regexp":{
"name.first": {
"value": "s.*y",
@ -73,7 +87,8 @@ this limit to allow more complex regular expressions to execute.
}
}
}
}
--------------------------------------------------
// CONSOLE
include::regexp-syntax.asciidoc[]

20
docs/reference/query-dsl/script-query.asciidoc
View File

@ -7,17 +7,20 @@ context, for example:
[source,js]
----------------------------------------------
GET /_search
{
"query": {
"bool" : {
"must" : {
...
},
"filter" : {
"script" : {
"script" : "doc['num1'].value > 1"
}
}
}
}
}
----------------------------------------------
// CONSOLE
[float]
==== Custom Parameters
@ -28,14 +31,14 @@ to use the ability to pass parameters to the script itself, for example:
[source,js]
----------------------------------------------
GET /_search
{
"query": {
"bool" : {
"must" : {
...
},
"filter" : {
"script" : {
"script" : {
"inline" : "doc['num1'].value > param1"
"inline" : "doc['num1'].value > param1",
"params" : {
"param1" : 5
}
@ -43,5 +46,8 @@ to use the ability to pass parameters to the script itself, for example:
}
}
}
}
}
----------------------------------------------
// CONSOLE

12
docs/reference/query-dsl/simple-query-string-query.asciidoc
View File

@ -8,7 +8,9 @@ an example:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"simple_query_string" : {
"query": "\"fried eggs\" +(eggplant | potato) -frittata",
"analyzer": "snowball",
@ -16,7 +18,9 @@ an example:
"default_operator": "and"
}
}
}
--------------------------------------------------
// CONSOLE
The `simple_query_string` top level parameters include:
@ -94,13 +98,17 @@ introduced fields included). For example:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"simple_query_string" : {
"fields" : ["content", "name.*^5"],
"query" : "foo bar baz"
}
}
}
--------------------------------------------------
// CONSOLE
[float]
==== Flags
@ -110,13 +118,17 @@ should be enabled. It is specified as a `|`-delimited string with the
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"simple_query_string" : {
"query" : "foo | bar + baz*",
"flags" : "OR|AND|PREFIX"
}
}
}
--------------------------------------------------
// CONSOLE
The available flags are: `ALL`, `NONE`, `AND`, `OR`, `NOT`, `PREFIX`, `PHRASE`,
`PRECEDENCE`, `ESCAPE`, `WHITESPACE`, `FUZZY`, `NEAR`, and `SLOP`.

4
docs/reference/query-dsl/span-containing-query.asciidoc
View File

@ -6,7 +6,9 @@ query maps to Lucene `SpanContainingQuery`. Here is an example:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"span_containing" : {
"little" : {
"span_term" : { "field1" : "foo" }
@ -23,7 +25,9 @@ query maps to Lucene `SpanContainingQuery`. Here is an example:
}
}
}
}
--------------------------------------------------
// CONSOLE
The `big` and `little` clauses can be any span type query. Matching
spans from `big` that contain matches from `little` are returned.

4
docs/reference/query-dsl/span-first-query.asciidoc
View File

@ -6,7 +6,9 @@ to Lucene `SpanFirstQuery`. Here is an example:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"span_first" : {
"match" : {
"span_term" : { "user" : "kimchy" }
@ -14,7 +16,9 @@ to Lucene `SpanFirstQuery`. Here is an example:
"end" : 3
}
}
}
--------------------------------------------------
// CONSOLE
The `match` clause can be any other span type query. The `end` controls
the maximum end position permitted in a match.

8
docs/reference/query-dsl/span-multi-term-query.asciidoc
View File

@ -7,24 +7,32 @@ it can be nested. Example:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"span_multi":{
"match":{
"prefix" : { "user" : { "value" : "ki" } }
}
}
}
}
--------------------------------------------------
// CONSOLE
A boost can also be associated with the query:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"span_multi":{
"match":{
"prefix" : { "user" : { "value" : "ki", "boost" : 1.08 } }
}
}
}
}
--------------------------------------------------
// CONSOLE

4
docs/reference/query-dsl/span-near-query.asciidoc
View File

@ -8,7 +8,9 @@ matches are required to be in-order. The span near query maps to Lucene
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"span_near" : {
"clauses" : [
{ "span_term" : { "field" : "value1" } },
@ -19,7 +21,9 @@ matches are required to be in-order. The span near query maps to Lucene
"in_order" : false
}
}
}
--------------------------------------------------
// CONSOLE
The `clauses` element is a list of one or more other span type queries
and the `slop` controls the maximum number of intervening unmatched

4
docs/reference/query-dsl/span-not-query.asciidoc
View File

@ -6,7 +6,9 @@ query maps to Lucene `SpanNotQuery`. Here is an example:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"span_not" : {
"include" : {
"span_term" : { "field1" : "hoya" }
@ -23,7 +25,9 @@ query maps to Lucene `SpanNotQuery`. Here is an example:
}
}
}
}
--------------------------------------------------
// CONSOLE
The `include` and `exclude` clauses can be any span type query. The
`include` clause is the span query whose matches are filtered, and the

4
docs/reference/query-dsl/span-or-query.asciidoc
View File

@ -6,7 +6,9 @@ Matches the union of its span clauses. The span or query maps to Lucene
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"span_or" : {
"clauses" : [
{ "span_term" : { "field" : "value1" } },
@ -15,6 +17,8 @@ Matches the union of its span clauses. The span or query maps to Lucene
]
}
}
}
--------------------------------------------------
// CONSOLE
The `clauses` element is a list of one or more other span type queries.

12
docs/reference/query-dsl/span-term-query.asciidoc
View File

@ -6,25 +6,37 @@ Matches spans containing a term. The span term query maps to Lucene
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"span_term" : { "user" : "kimchy" }
}
}
--------------------------------------------------
// CONSOLE
A boost can also be associated with the query:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"span_term" : { "user" : { "value" : "kimchy", "boost" : 2.0 } }
}
}
--------------------------------------------------
// CONSOLE
Or :
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"span_term" : { "user" : { "term" : "kimchy", "boost" : 2.0 } }
}
}
--------------------------------------------------
// CONSOLE

4
docs/reference/query-dsl/span-within-query.asciidoc
View File

@ -6,7 +6,9 @@ query maps to Lucene `SpanWithinQuery`. Here is an example:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"span_within" : {
"little" : {
"span_term" : { "field1" : "foo" }
@ -23,7 +25,9 @@ query maps to Lucene `SpanWithinQuery`. Here is an example:
}
}
}
}
--------------------------------------------------
// CONSOLE
The `big` and `little` clauses can be any span type query. Matching
spans from `little` that are enclosed within `big` are returned.

15
docs/reference/query-dsl/template-query.asciidoc
View File

@ -19,8 +19,8 @@ GET /_search
}
}
}
------------------------------------------
// CONSOLE
The above request is translated into:
@ -34,8 +34,8 @@ GET /_search
}
}
}
------------------------------------------
// CONSOLE
Alternatively passing the template as an escaped string works as well:
@ -53,6 +53,8 @@ GET /_search
}
}
------------------------------------------
// CONSOLE
<1> New line characters (`\n`) should be escaped as `\\n` or removed,
and quotes (`"`) should be escaped as `\\"`.
@ -77,6 +79,8 @@ GET /_search
}
}
------------------------------------------
// CONSOLE
<1> Name of the query template in `config/scripts/`, i.e., `my_template.mustache`.
Alternatively, you can register a query template in the cluster state with:
@ -85,9 +89,10 @@ Alternatively, you can register a query template in the cluster state with:
------------------------------------------
PUT /_search/template/my_template
{
"template": { "match": { "text": "{{query_string}}" }},
"template": { "match": { "text": "{{query_string}}" }}
}
------------------------------------------
// CONSOLE
and refer to it in the `template` query with the `id` parameter:
@ -106,9 +111,13 @@ GET /_search
}
}
------------------------------------------
// CONSOLE
// TEST[continued]
<1> Name of the query template in `config/scripts/`, i.e., `my_template.mustache`.
There is also a dedicated `template` endpoint, allows you to template an entire search request.
Please see <<search-template>> for more details.

26
docs/reference/query-dsl/terms-query.asciidoc
View File

@ -6,14 +6,18 @@ Filters documents that have fields that match any of the provided terms
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"constant_score" : {
"filter" : {
"terms" : { "user" : ["kimchy", "elasticsearch"]}
}
}
}
}
--------------------------------------------------
// CONSOLE
The `terms` query is also aliased with `in` as the filter name for
simpler usage deprecated[5.0.0,use `terms` instead].
@ -63,21 +67,24 @@ possible, reducing the need for networking.
[float]
===== Terms lookup twitter example
At first we index the information for user with id 2, specifically, its
followers, than index a tweet from user with id 1. Finally we search on
all the tweets that match the followers of user 2.
[source,js]
--------------------------------------------------
# index the information for user with id 2, specifically, its followers
curl -XPUT localhost:9200/users/user/2 -d '{
PUT /users/user/2
{
"followers" : ["1", "3"]
}'
}
# index a tweet, from user with id 1
curl -XPUT localhost:9200/tweets/tweet/1 -d '{
PUT /tweets/tweet/1
{
"user" : "1"
}'
}
# search on all the tweets that match the followers of user 2
curl -XGET localhost:9200/tweets/_search -d '{
GET /tweets/_search
{
"query" : {
"terms" : {
"user" : {
@ -88,8 +95,9 @@ curl -XGET localhost:9200/tweets/_search -d '{
}
}
}
}'
}
--------------------------------------------------
// CONSOLE
The structure of the external terms document can also include array of
inner objects, for example:

4
docs/reference/query-dsl/type-query.asciidoc
View File

@ -5,9 +5,13 @@ Filters documents matching the provided document / mapping type.
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"type" : {
"value" : "my_type"
}
}
}
--------------------------------------------------
// CONSOLE

12
docs/reference/query-dsl/wildcard-query.asciidoc
View File

@ -11,28 +11,40 @@ query maps to Lucene `WildcardQuery`.
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"wildcard" : { "user" : "ki*y" }
}
}
--------------------------------------------------
// CONSOLE
A boost can also be associated with the query:
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"wildcard" : { "user" : { "value" : "ki*y", "boost" : 2.0 } }
}
}
--------------------------------------------------
// CONSOLE
Or :
[source,js]
--------------------------------------------------
GET /_search
{
"query": {
"wildcard" : { "user" : { "wildcard" : "ki*y", "boost" : 2.0 } }
}
}
--------------------------------------------------
// CONSOLE
This multi term query allows to control how it gets rewritten using the
<<query-dsl-multi-term-rewrite,rewrite>>