Merge pull request #18544 from MaineC/docs/add_autosense_to_query_dsl

Add back doc execution to query dsl.

docs/reference/query-dsl/bool-query.asciidoc

@@ -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
 {

docs/reference/query-dsl/boosting-query.asciidoc

@@ -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

docs/reference/query-dsl/common-terms-query.asciidoc

@@ -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": "the"}},
-      { "term": { "body": "as"}}
+            { "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": "the"}},
-      { "term": { "body": "as"}}
+                { "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`.

docs/reference/query-dsl/constant-score-query.asciidoc

@@ -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

docs/reference/query-dsl/dis-max-query.asciidoc

@@ -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

docs/reference/query-dsl/exists-query.asciidoc

@@ -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.
 

docs/reference/query-dsl/function-score-query.asciidoc

@@ -14,13 +14,20 @@ by the query.
 
 [source,js]
 --------------------------------------------------
+GET /_search
+{
+    "query": {
         "function_score": {
             "query": {},
-    "boost": "boost for the whole query",
+            "boost": "5",
-    "FUNCTION": {}, <1>
+            "random_score": {}, <1>
-    "boost_mode":"(multiply|replace|...)"
+            "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>
+                  "random_score": {}, <2>
-            "weight": number
+                  "weight": 23
-        },
-        {
-            "FUNCTION": {} <1>
               },
               {
                   "filter": {},
-            "weight": number
+                  "weight": 42 
               }
           ],
-    "max_boost": number,
+          "max_boost": 42,
-    "score_mode": "(multiply|max|...)",
+          "score_mode": "max",
-    "boost_mode": "(multiply|replace|...)",
+          "boost_mode": "multiply",
-    "min_score" : number
+          "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": {

docs/reference/query-dsl/fuzzy-query.asciidoc

@@ -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!
 
+

docs/reference/query-dsl/geo-bounding-box-query.asciidoc

@@ -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

docs/reference/query-dsl/geo-distance-query.asciidoc

@@ -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

docs/reference/query-dsl/geo-distance-range-query.asciidoc

@@ -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>>

docs/reference/query-dsl/geo-polygon-query.asciidoc

@@ -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

docs/reference/query-dsl/geo-shape-query.asciidoc

@@ -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
 

docs/reference/query-dsl/geohash-cell-query.asciidoc

@@ -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

docs/reference/query-dsl/has-child-query.asciidoc

@@ -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

docs/reference/query-dsl/has-parent-query.asciidoc

@@ -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

docs/reference/query-dsl/ids-query.asciidoc

@@ -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.

docs/reference/query-dsl/indices-query.asciidoc

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

docs/reference/query-dsl/match-all-query.asciidoc

@@ -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

docs/reference/query-dsl/match-phrase-prefix-query.asciidoc

@@ -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]
 ===================================================

docs/reference/query-dsl/match-phrase-query.asciidoc

@@ -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

docs/reference/query-dsl/match-query.asciidoc

@@ -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

docs/reference/query-dsl/mlt-query.asciidoc

@@ -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
 

docs/reference/query-dsl/multi-match-query.asciidoc

@@ -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:

docs/reference/query-dsl/nested-query.asciidoc

@@ -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"} },
-                        "match" : {"obj1.name" : "blue"}
+                    { "range" : {"obj1.count" : {"gt" : 5}} }
-                    },
-                    {
-                        "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

docs/reference/query-dsl/parent-id-query.asciidoc

@@ -54,9 +54,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"
@@ -64,7 +66,9 @@ better as it does not need to do a join:
       }
     }
   }
+}
 --------------------------------------------------
+// CONSOLE
 
 ==== Parameters
 

docs/reference/query-dsl/percolate-query.asciidoc

@@ -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.
 
@@ -344,16 +360,19 @@ can't do the selecting optimization (for example if an unsupported query is defi
 or the unsupported query is the only query in the percolator document).  These queries are marked by the percolator and
 can be found by running the following search:
 
+
 [source,js]
---------------------------------------------------
+---------------------------------------------------
-curl -XGET "http://localhost:9200/_search" -d'
+GET /_search
 {
   "query": {
     "term" : {
       "query.unknown_query" : ""
     }
   }
-}'
+}
---------------------------------------------------
+---------------------------------------------------
+// CONSOLE
 
-NOTE: The above example assumes that there is a `query` field of type `percolator` in the mappings.
+NOTE: The above example assumes that there is a `query` field of type
+`percolator` in the mappings.

docs/reference/query-dsl/prefix-query.asciidoc

@@ -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>>

docs/reference/query-dsl/query-string-query.asciidoc

@@ -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[]

docs/reference/query-dsl/query_filter_context.asciidoc

@@ -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

docs/reference/query-dsl/range-query.asciidoc

@@ -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).

docs/reference/query-dsl/regexp-query.asciidoc

@@ -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[]

docs/reference/query-dsl/script-query.asciidoc

@@ -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
 

docs/reference/query-dsl/simple-query-string-query.asciidoc

@@ -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`.

docs/reference/query-dsl/span-containing-query.asciidoc

@@ -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.

docs/reference/query-dsl/span-first-query.asciidoc

@@ -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.

docs/reference/query-dsl/span-multi-term-query.asciidoc

@@ -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

docs/reference/query-dsl/span-near-query.asciidoc

@@ -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

docs/reference/query-dsl/span-not-query.asciidoc

@@ -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

docs/reference/query-dsl/span-or-query.asciidoc

@@ -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.

docs/reference/query-dsl/span-term-query.asciidoc

@@ -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

docs/reference/query-dsl/span-within-query.asciidoc

@@ -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.

docs/reference/query-dsl/template-query.asciidoc

@@ -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.
 
+

docs/reference/query-dsl/terms-query.asciidoc

@@ -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
+PUT /users/user/2
-curl -XPUT localhost:9200/users/user/2 -d '{
+{
     "followers" : ["1", "3"]
-}'
+}
 
-# index a tweet, from user with id 1
+PUT /tweets/tweet/1
-curl -XPUT localhost:9200/tweets/tweet/1 -d '{
+{
     "user" : "1"
-}'
+}
 
-# search on all the tweets that match the followers of user 2
+GET /tweets/_search
-curl -XGET localhost:9200/tweets/_search -d '{
+{
     "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:

docs/reference/query-dsl/type-query.asciidoc

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

docs/reference/query-dsl/wildcard-query.asciidoc

@@ -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>>