Add back doc execution to query dsl.

Relates to #18211

This reverts commit 20aafb1196192d4f9f7faea8ce9a36b278e501a1.

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,19 +8,23 @@ overall score.
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "boosting" : {
-        "positive" : {
-            "term" : {
-                "field1" : "value1"
-            }
-        },
-        "negative" : {
-            "term" : {
-                "field2" : "value2"
-            }
-        },
-        "negative_boost" : 0.2
+    "query": {
+        "boosting" : {
+            "positive" : {
+                "term" : {
+                    "field1" : "value1"
+                }
+            },
+            "negative" : {
+                 "term" : {
+                     "field2" : "value2"
+                }
+            },
+            "negative_boost" : 0.2
+        }
     }
 }
 --------------------------------------------------
+// CONSOLE

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

@@ -70,15 +70,19 @@ In this example, words that have a document frequency greater than 0.1%
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "common": {
-    "body": {
-      "query": "this is bonsai cool",
-      "cutoff_frequency": 0.001
+    "query": {
+        "common": {
+            "body": {
+                "query": "this is bonsai cool",
+                    "cutoff_frequency": 0.001
+            }
+        }
     }
-  }
 }
 --------------------------------------------------
+// CONSOLE
 
 The number of terms which should match can be controlled with the
 <<query-dsl-minimum-should-match,`minimum_should_match`>>
@@ -90,36 +94,44 @@ all terms required:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "common": {
-    "body": {
-      "query": "nelly the elephant as a cartoon",
-      "cutoff_frequency": 0.001,
-      "low_freq_operator": "and"
+    "query": {
+        "common": {
+            "body": {
+                "query": "nelly the elephant as a cartoon",
+                    "cutoff_frequency": 0.001,
+                    "low_freq_operator": "and"
+            }
+        }
     }
-  }
 }
 --------------------------------------------------
+// CONSOLE
 
 which is roughly equivalent to:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "bool": {
-    "must": [
-      { "term": { "body": "nelly"}},
-      { "term": { "body": "elephant"}},
-      { "term": { "body": "cartoon"}}
-    ],
-    "should": [
-      { "term": { "body": "the"}}
-      { "term": { "body": "as"}}
-      { "term": { "body": "a"}}
-    ]
-  }
+    "query": {
+        "bool": {
+            "must": [
+            { "term": { "body": "nelly"}},
+            { "term": { "body": "elephant"}},
+            { "term": { "body": "cartoon"}}
+            ],
+            "should": [
+            { "term": { "body": "the"}},
+            { "term": { "body": "as"}},
+            { "term": { "body": "a"}}
+            ]
+        }
+    }
 }
 --------------------------------------------------
+// CONSOLE
 
 Alternatively use
 <<query-dsl-minimum-should-match,`minimum_should_match`>>
@@ -128,41 +140,49 @@ must be present, for instance:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "common": {
-    "body": {
-      "query": "nelly the elephant as a cartoon",
-      "cutoff_frequency": 0.001,
-      "minimum_should_match": 2
+    "query": {
+        "common": {
+            "body": {
+                "query": "nelly the elephant as a cartoon",
+                "cutoff_frequency": 0.001,
+                "minimum_should_match": 2
+            }
+        }
     }
-  }
 }
 --------------------------------------------------
+// CONSOLE
 
 which is roughly equivalent to:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "bool": {
-    "must": {
-      "bool": {
-        "should": [
-          { "term": { "body": "nelly"}},
-          { "term": { "body": "elephant"}},
-          { "term": { "body": "cartoon"}}
-        ],
-        "minimum_should_match": 2
-      }
-    },
-    "should": [
-      { "term": { "body": "the"}}
-      { "term": { "body": "as"}}
-      { "term": { "body": "a"}}
-    ]
-  }
+    "query": {
+        "bool": {
+            "must": {
+                "bool": {
+                    "should": [
+                    { "term": { "body": "nelly"}},
+                    { "term": { "body": "elephant"}},
+                    { "term": { "body": "cartoon"}}
+                    ],
+                    "minimum_should_match": 2
+                }
+            },
+            "should": [
+                { "term": { "body": "the"}},
+                { "term": { "body": "as"}},
+                { "term": { "body": "a"}}
+                ]
+        }
+    }
 }
 --------------------------------------------------
+// CONSOLE
 
 minimum_should_match
 
@@ -174,50 +194,58 @@ additional parameters (note the change in structure):
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "common": {
-    "body": {
-      "query": "nelly the elephant not as a cartoon",
-      "cutoff_frequency": 0.001,
-      "minimum_should_match": {
-          "low_freq" : 2,
-          "high_freq" : 3
-       }
+    "query": {
+        "common": {
+            "body": {
+                "query": "nelly the elephant not as a cartoon",
+                    "cutoff_frequency": 0.001,
+                    "minimum_should_match": {
+                        "low_freq" : 2,
+                        "high_freq" : 3
+                    }
+            }
+        }
     }
-  }
 }
 --------------------------------------------------
+// CONSOLE
 
 which is roughly equivalent to:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "bool": {
-    "must": {
-      "bool": {
-        "should": [
-          { "term": { "body": "nelly"}},
-          { "term": { "body": "elephant"}},
-          { "term": { "body": "cartoon"}}
-        ],
-        "minimum_should_match": 2
-      }
-    },
-    "should": {
-      "bool": {
-        "should": [
-          { "term": { "body": "the"}},
-          { "term": { "body": "not"}},
-          { "term": { "body": "as"}},
-          { "term": { "body": "a"}}
-        ],
-        "minimum_should_match": 3
-      }
+    "query": {
+        "bool": {
+            "must": {
+                "bool": {
+                    "should": [
+                    { "term": { "body": "nelly"}},
+                    { "term": { "body": "elephant"}},
+                    { "term": { "body": "cartoon"}}
+                    ],
+                    "minimum_should_match": 2
+                }
+            },
+            "should": {
+                "bool": {
+                    "should": [
+                    { "term": { "body": "the"}},
+                    { "term": { "body": "not"}},
+                    { "term": { "body": "as"}},
+                    { "term": { "body": "a"}}
+                    ],
+                    "minimum_should_match": 3
+                }
+            }
+        }
     }
-  }
 }
 --------------------------------------------------
+// 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,36 +255,44 @@ for high frequency terms is when there are only high frequency terms:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "common": {
-    "body": {
-      "query": "how not to be",
-      "cutoff_frequency": 0.001,
-      "minimum_should_match": {
-          "low_freq" : 2,
-          "high_freq" : 3
-       }
+    "query": {
+        "common": {
+            "body": {
+                "query": "how not to be",
+                    "cutoff_frequency": 0.001,
+                    "minimum_should_match": {
+                        "low_freq" : 2,
+                        "high_freq" : 3
+                    }
+            }
+        }
     }
-  }
 }
 --------------------------------------------------
+// CONSOLE
 
 which is roughly equivalent to:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "bool": {
-    "should": [
-      { "term": { "body": "how"}},
-      { "term": { "body": "not"}},
-      { "term": { "body": "to"}},
-      { "term": { "body": "be"}}
-    ],
-    "minimum_should_match": "3<50%"
-  }
+    "query": {
+        "bool": {
+            "should": [
+            { "term": { "body": "how"}},
+            { "term": { "body": "not"}},
+            { "term": { "body": "to"}},
+            { "term": { "body": "be"}}
+            ],
+            "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,12 +7,16 @@ filter. Maps to Lucene `ConstantScoreQuery`.
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "constant_score" : {
-        "filter" : {
-            "term" : { "user" : "kimchy"}
-        },
-        "boost" : 1.2
+    "query": {
+        "constant_score" : {
+            "filter" : {
+                "term" : { "user" : "kimchy"}
+            },
+            "boost" : 1.2
+        }
     }
 }
 --------------------------------------------------
+// CONSOLE

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

@@ -27,18 +27,22 @@ This query maps to Lucene `DisjunctionMaxQuery`.
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "dis_max" : {
-        "tie_breaker" : 0.7,
-        "boost" : 1.2,
-        "queries" : [
-            {
-                "term" : { "age" : 34 }
-            },
-            {
-                "term" : { "age" : 35 }
-            }
-        ]
+    "query": {
+        "dis_max" : {
+            "tie_breaker" : 0.7,
+                "boost" : 1.2,
+                "queries" : [
+                {
+                    "term" : { "age" : 34 }
+                },
+                {
+                    "term" : { "age" : 35 }
+                }
+                ]
+        }
     }
 }    
 --------------------------------------------------
+// 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
 {
-    "exists" : { "field" : "user" }
+    "query": {
+        "exists" : { "field" : "user" }
+    }
 }
 --------------------------------------------------
+// CONSOLE
 
 For instance, these documents would all match the above query:
 
@@ -77,14 +81,20 @@ clause as follows:
 
 [source,js]
 --------------------------------------------------
-"bool": {
-    "must_not": {
-        "exists": {
-            "field": "user"
+GET /_search
+{
+    "query": {
+        "bool": {
+            "must_not": {
+                "exists": {
+                    "field": "user"
+                }
+            }
         }
     }
 }
 --------------------------------------------------
+// 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]
 --------------------------------------------------
-"function_score": {
-    "query": {},
-    "boost": "boost for the whole query",
-    "FUNCTION": {}, <1>
-    "boost_mode":"(multiply|replace|...)"
+GET /_search
+{
+    "query": {
+        "function_score": {
+            "query": {},
+            "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]
 --------------------------------------------------
-"function_score": {
-    "query": {},
-    "boost": "boost for the whole query",
-    "functions": [
-        {
-            "filter": {},
-            "FUNCTION": {}, <1>
-            "weight": number
-        },
-        {
-            "FUNCTION": {} <1>
-        },
-        {
-            "filter": {},
-            "weight": number
+GET /_search
+{
+    "query": {
+        "function_score": {
+          "query": {},
+          "boost": "5", <1>
+          "functions": [
+              {
+                  "filter": {},
+                  "random_score": {}, <2>
+                  "weight": 23
+              },
+              {
+                  "filter": {},
+                  "weight": 42 
+              }
+          ],
+          "max_boost": 42,
+          "score_mode": "max",
+          "boost_mode": "multiply",
+          "min_score" : 42
         }
-    ],
-    "max_boost": number,
-    "score_mode": "(multiply|max|...)",
-    "boost_mode": "(multiply|replace|...)",
-    "min_score" : number
+    }
 }
 --------------------------------------------------
-<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,36 +471,36 @@ the request would look like this:
 
 [source,js]
 --------------------------------------------------
-GET _search
+GET /_search
 {
-  "query": {
-    "function_score": {
-      "functions": [
-        {
-          "gauss": {
-            "price": {
-              "origin": "0",
-              "scale": "20"
+    "query": {
+        "function_score": {
+          "functions": [
+            {
+              "gauss": {
+                "price": {
+                  "origin": "0",
+                  "scale": "20"
+                }
+              }
+            },
+            {
+              "gauss": {
+                "location": {
+                  "origin": "11, 12",
+                  "scale": "2km"
+                }
+              }
             }
-          }
-        },
-        {
-          "gauss": {
-            "location": {
-              "origin": "11, 12",
-              "scale": "2km"
+          ],
+          "query": {
+            "match": {
+              "properties": "balcony"
             }
-          }
-        }
-      ],
-      "query": {
-        "match": {
-          "properties": "balcony"
+          },
+          "score_mode": "multiply"
         }
-      },
-      "score_mode": "multiply"
     }
-  }
 }
 --------------------------------------------------
 // CONSOLE

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

@@ -16,27 +16,35 @@ Here is a simple example:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "fuzzy" : { "user" : "ki" }
+    "query": {
+       "fuzzy" : { "user" : "ki" }
+    }
 }
 --------------------------------------------------
+// CONSOLE
 
 Or with more advanced settings:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "fuzzy" : {
-        "user" : {
-            "value" :         "ki",
-            "boost" :         1.0,
-            "fuzziness" :     2,
-            "prefix_length" : 0,
-            "max_expansions": 100
+    "query": {
+        "fuzzy" : {
+            "user" : {
+                "value" :         "ki",
+                    "boost" :         1.0,
+                    "fuzziness" :     2,
+                    "prefix_length" : 0,
+                    "max_expansions": 100
+            }
         }
     }
 }
 --------------------------------------------------
+// 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,27 +33,32 @@ 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
 {
-    "bool" : {
-        "must" : {
-            "match_all" : {}
-        },
-        "filter" : {
-            "geo_bounding_box" : {
-                "pin.location" : {
-                    "top_left" : {
-                        "lat" : 40.73,
-                        "lon" : -74.1
-                    },
-                    "bottom_right" : {
-                        "lat" : 40.01,
-                        "lon" : -71.12
+    "query": {
+        "bool" : {
+            "must" : {
+                "match_all" : {}
+            },
+            "filter" : {
+                "geo_bounding_box" : {
+                    "pin.location" : {
+                        "top_left" : {
+                            "lat" : 40.73,
+                            "lon" : -74.1
+                        },
+                        "bottom_right" : {
+                            "lat" : 40.01,
+                            "lon" : -71.12
+                        }
                     }
                 }
             }
@@ -43,6 +66,7 @@ Then the following simple query can be executed with a
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [float]
 ==== Query Options
@@ -75,21 +99,24 @@ representation of the geo point, the filter can accept it as well:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "bool" : {
-        "must" : {
-            "match_all" : {}
-        },
-        "filter" : {
-            "geo_bounding_box" : {
-                "pin.location" : {
-                    "top_left" : {
-                        "lat" : 40.73,
-                        "lon" : -74.1
-                    },
-                    "bottom_right" : {
-                        "lat" : 40.01,
-                        "lon" : -71.12
+    "query": {
+        "bool" : {
+            "must" : {
+                "match_all" : {}
+            },
+            "filter" : {
+                "geo_bounding_box" : {
+                    "pin.location" : {
+                        "top_left" : {
+                            "lat" : 40.73,
+                            "lon" : -74.1
+                        },
+                        "bottom_right" : {
+                            "lat" : 40.01,
+                            "lon" : -71.12
+                        }
                     }
                 }
             }
@@ -97,6 +124,7 @@ representation of the geo point, the filter can accept it as well:
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [float]
 ===== Lat Lon As Array
@@ -106,22 +134,26 @@ conform with http://geojson.org/[GeoJSON].
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "bool" : {
-        "must" : {
-            "match_all" : {}
-        },
-        "filter" : {
-            "geo_bounding_box" : {
-                "pin.location" : {
-                    "top_left" : [-74.1, 40.73],
-                    "bottom_right" : [-71.12, 40.01]
+    "query": {
+        "bool" : {
+            "must" : {
+                "match_all" : {}
+            },
+            "filter" : {
+                "geo_bounding_box" : {
+                    "pin.location" : {
+                        "top_left" : [-74.1, 40.73],
+                        "bottom_right" : [-71.12, 40.01]
+                    }
                 }
             }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [float]
 ===== Lat Lon As String
@@ -130,44 +162,52 @@ Format in `lat,lon`.
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "bool" : {
-        "must" : {
-            "match_all" : {}
-        },
-        "filter" : {
-            "geo_bounding_box" : {
-                "pin.location" : {
-                    "top_left" : "40.73, -74.1",
-                    "bottom_right" : "40.01, -71.12"
+    "query": {
+        "bool" : {
+            "must" : {
+                "match_all" : {}
+            },
+            "filter" : {
+                "geo_bounding_box" : {
+                    "pin.location" : {
+                        "top_left" : "40.73, -74.1",
+                        "bottom_right" : "40.01, -71.12"
+                    }
                 }
             }
-        }
     }
 }
+}
 --------------------------------------------------
+// CONSOLE
 
 [float]
 ===== Geohash
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "bool" : {
-        "must" : {
-            "match_all" : {}
-        },
-        "filter" : {
-            "geo_bounding_box" : {
-                "pin.location" : {
-                    "top_left" : "dr5r9ydj2y73",
-                    "bottom_right" : "drj7teegpus6"
+    "query": {
+        "bool" : {
+            "must" : {
+                "match_all" : {}
+            },
+            "filter" : {
+                "geo_bounding_box" : {
+                    "pin.location" : {
+                        "top_left" : "dr5r9ydj2y73",
+                        "bottom_right" : "drj7teegpus6"
+                    }
                 }
             }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [float]
 ==== Vertices
@@ -181,24 +221,28 @@ values separately.
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "bool" : {
-        "must" : {
-            "match_all" : {}
-        },
-        "filter" : {
-            "geo_bounding_box" : {
-                "pin.location" : {
-                    "top" : 40.73,
-                    "left" : -74.1,
-                    "bottom" : 40.01,
-                    "right" : -71.12
+    "query": {
+        "bool" : {
+            "must" : {
+                "match_all" : {}
+            },
+            "filter" : {
+                "geo_bounding_box" : {
+                    "pin.location" : {
+                        "top" : 40.73,
+                        "left" : -74.1,
+                        "bottom" : 40.01,
+                        "right" : -71.12
+                    }
                 }
             }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 
 [float]
@@ -227,29 +271,33 @@ are not supported. Here is an example:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "bool" : {
-        "must" : {
-            "match_all" : {}
-        },
-        "filter" : {
-            "geo_bounding_box" : {
-                "pin.location" : {
-                    "top_left" : {
-                        "lat" : 40.73,
-                        "lon" : -74.1
+    "query": {
+        "bool" : {
+            "must" : {
+                "match_all" : {}
+            },
+            "filter" : {
+                "geo_bounding_box" : {
+                    "pin.location" : {
+                        "top_left" : {
+                            "lat" : 40.73,
+                            "lon" : -74.1
+                        },
+                        "bottom_right" : {
+                            "lat" : 40.10,
+                            "lon" : -71.12
+                        }
                     },
-                    "bottom_right" : {
-                        "lat" : 40.10,
-                        "lon" : -71.12
-                    }
-                },
-                "type" : "indexed"
+                    "type" : "indexed"
+                }
             }
         }
     }
 }
 --------------------------------------------------
+// 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,29 +34,36 @@ 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
 {
-    "bool" : {
-        "must" : {
-            "match_all" : {}
-        },
-        "filter" : {
-            "geo_distance" : {
-                "distance" : "200km",
-                "pin.location" : {
-                    "lat" : 40,
-                    "lon" : -70
+    "query": {
+        "bool" : {
+            "must" : {
+                "match_all" : {}
+            },
+            "filter" : {
+                "geo_distance" : {
+                    "distance" : "200km",
+                    "pin.location" : {
+                        "lat" : 40,
+                        "lon" : -70
+                    }
                 }
             }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [float]
 ==== Accepted Formats
@@ -50,23 +76,27 @@ representation of the geo point, the filter can accept it as well:
 
 [source,js]
 --------------------------------------------------
+GET /my_locations/location/_search
 {
-    "bool" : {
-        "must" : {
-            "match_all" : {}
-        },
-        "filter" : {
-            "geo_distance" : {
-                "distance" : "12km",
-                "pin.location" : {
-                    "lat" : 40,
-                    "lon" : -70
+    "query": {
+        "bool" : {
+            "must" : {
+                "match_all" : {}
+            },
+            "filter" : {
+                "geo_distance" : {
+                    "distance" : "12km",
+                    "pin.location" : {
+                        "lat" : 40,
+                        "lon" : -70
+                    }
                 }
             }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [float]
 ===== Lat Lon As Array
@@ -76,20 +106,25 @@ conform with http://geojson.org/[GeoJSON].
 
 [source,js]
 --------------------------------------------------
+GET /my_locations/location/_search
 {
-    "bool" : {
-        "must" : {
-            "match_all" : {}
-        },
-        "filter" : {
-            "geo_distance" : {
-                "distance" : "12km",
-                "pin.location" : [-70, 40]
+    "query": {
+        "bool" : {
+            "must" : {
+                "match_all" : {}
+            },
+            "filter" : {
+                "geo_distance" : {
+                    "distance" : "12km",
+                    "pin.location" : [-70, 40]
+                }
             }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
+
 
 [float]
 ===== Lat Lon As String
@@ -98,40 +133,48 @@ Format in `lat,lon`.
 
 [source,js]
 --------------------------------------------------
+GET /my_locations/location/_search
 {
-    "bool" : {
-        "must" : {
-            "match_all" : {}
-        },
-        "filter" : {
-            "geo_distance" : {
-                "distance" : "12km",
-                "pin.location" : "40,-70"
+    "query": {
+        "bool" : {
+            "must" : {
+                "match_all" : {}
+            },
+            "filter" : {
+                "geo_distance" : {
+                    "distance" : "12km",
+                    "pin.location" : "40,-70"
+                }
             }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [float]
 ===== Geohash
 
 [source,js]
 --------------------------------------------------
+GET /my_locations/location/_search
 {
-    "bool" : {
-        "must" : {
-            "match_all" : {}
-        },
-        "filter" : {
-            "geo_distance" : {
-                "distance" : "12km",
-                "pin.location" : "drm3btev3e86"
+    "query": {
+        "bool" : {
+            "must" : {
+                "match_all" : {}
+            },
+            "filter" : {
+                "geo_distance" : {
+                    "distance" : "12km",
+                    "pin.location" : "drm3btev3e86"
+                }
             }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [float]
 ==== Options

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

@@ -5,24 +5,28 @@ Filters documents that exists within a range from a specific point:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "bool" : {
-        "must" : {
-            "match_all" : {}
-        },
-        "filter" : {
-            "geo_distance_range" : {
-                "from" : "200km",
-                "to" : "400km",
-                "pin.location" : {
-                    "lat" : 40,
-                    "lon" : -70
+    "query": {
+        "bool" : {
+            "must" : {
+                "match_all" : {}
+            },
+            "filter" : {
+                "geo_distance_range" : {
+                    "from" : "200km",
+                    "to" : "400km",
+                    "pin.location" : {
+                        "lat" : 40,
+                        "lon" : -70
+                    }
                 }
             }
         }
     }
 }
 --------------------------------------------------
+// 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,25 +6,29 @@ points. Here is an example:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "bool" : {
-        "query" : {
-            "match_all" : {}
-        },
-        "filter" : {
-            "geo_polygon" : {
-                "person.location" : {
-                    "points" : [
+    "query": {
+        "bool" : {
+            "must" : {
+                "match_all" : {}
+            },
+            "filter" : {
+                "geo_polygon" : {
+                    "person.location" : {
+                        "points" : [
                         {"lat" : 40, "lon" : -70},
                         {"lat" : 30, "lon" : -80},
                         {"lat" : 20, "lon" : -90}
-                    ]
+                        ]
+                    }
                 }
             }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [float]
 ==== Query Options
@@ -53,25 +57,29 @@ conform with http://geojson.org/[GeoJSON].
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "bool" : {
-        "must" : {
-            "match_all" : {}
-        },
-        "filter" : {
-            "geo_polygon" : {
-                "person.location" : {
-                    "points" : [
-                        [-70, 40],
+    "query": {
+        "bool" : {
+            "must" : {
+                "match_all" : {}
+            },
+            "filter" : {
+                "geo_polygon" : {
+                    "person.location" : {
+                        "points" : [
+                            [-70, 40],
                         [-80, 30],
-                        [-90, 20]
-                    ]
+                            [-90, 20]
+                        ]
+                    }
                 }
             }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [float]
 ===== Lat Lon as String
@@ -80,50 +88,58 @@ Format in `lat,lon`.
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "bool" : {
-        "must" : {
-            "match_all" : {}
-        },
-        "filter" : {
-            "geo_polygon" : {
-                "person.location" : {
-                    "points" : [
-                        "40, -70",
-                        "30, -80",
-                        "20, -90"
-                    ]
+    "query": {
+        "bool" : {
+            "must" : {
+                "match_all" : {}
+            },
+            "filter" : {
+               "geo_polygon" : {
+                    "person.location" : {
+                        "points" : [
+                            "40, -70",
+                            "30, -80",
+                            "20, -90"
+                        ]
+                    }
                 }
             }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [float]
 ===== Geohash
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "bool" : {
-        "must" : {
-            "match_all" : {}
-        },
-        "filter" : {
-            "geo_polygon" : {
-                "person.location" : {
-                    "points" : [
-                        "drn5x1g8cu2y",
-                        "30, -80",
-                        "20, -90"
-                    ]
+    "query": {
+        "bool" : {
+            "must" : {
+                "match_all" : {}
+            },
+            "filter" : {
+               "geo_polygon" : {
+                    "person.location" : {
+                        "points" : [
+                            "drn5x1g8cu2y",
+                            "30, -80",
+                            "20, -90"
+                        ]
+                    }
                 }
             }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [float]
 ==== geo_point Type

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

@@ -26,10 +26,10 @@ Given a document that looks like this:
 --------------------------------------------------
 {
     "name": "Wind & Wetter, Berlin, Germany",
-    "location": {
-        "type": "Point",
-        "coordinates": [13.400544, 52.530286]
-    }
+        "location": {
+            "type": "Point",
+            "coordinates": [13.400544, 52.530286]
+        }
 }
 --------------------------------------------------
 
@@ -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,26 +83,30 @@ shape:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "bool": {
-        "must": {
-            "match_all": {}
-        },
-        "filter": {
-            "geo_shape": {
-                "location": {
-                    "indexed_shape": {
-                        "id": "DEU",
-                        "type": "countries",
-                        "index": "shapes",
-                        "path": "location"
+    "query": {
+        "bool": {
+            "must": {
+                "match_all": {}
+            },
+                "filter": {
+                    "geo_shape": {
+                        "location": {
+                            "indexed_shape": {
+                                "id": "DEU",
+                                "type": "countries",
+                                "index": "shapes",
+                                "path": "location"
+                            }
+                        }
                     }
                 }
-            }
         }
     }
 }
 --------------------------------------------------
+// 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,24 +45,28 @@ next to the given cell.
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "bool" : {
-        "must" : {
-            "match_all" : {}
-        },
-        "filter" : {
-            "geohash_cell": {
-                "pin": {
-                    "lat": 13.4080,
-                    "lon": 52.5186
-                },
-                "precision": 3,
-                "neighbors": true
+    "query": {
+        "bool" : {
+            "must" : {
+                "match_all" : {}
+            },
+            "filter" : {
+                "geohash_cell": {
+                    "pin": {
+                        "lat": 13.4080,
+                        "lon": 52.5186
+                    },
+                    "precision": 3,
+                    "neighbors": true
+                }
             }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [float]
 ==== Ignore Unmapped

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

@@ -7,17 +7,21 @@ an example:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "has_child" : {
-        "type" : "blog_tag",
-        "query" : {
-            "term" : {
-                "tag" : "something"
-            }
+    "query": {
+        "has_child" : {
+            "type" : "blog_tag",
+                "query" : {
+                    "term" : {
+                        "tag" : "something"
+                    }
+                }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [float]
 ==== Scoring capabilities
@@ -32,18 +36,22 @@ inside the `has_child` query:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "has_child" : {
-        "type" : "blog_tag",
-        "score_mode" : "min",
-        "query" : {
-            "term" : {
-                "tag" : "something"
-            }
+    "query": {
+        "has_child" : {
+            "type" : "blog_tag",
+                "score_mode" : "min",
+                "query" : {
+                    "term" : {
+                        "tag" : "something"
+                    }
+                }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [float]
 ==== Min/Max Children
@@ -54,20 +62,24 @@ a match:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "has_child" : {
-        "type" : "blog_tag",
-        "score_mode" : "min",
-        "min_children": 2, <1>
-        "max_children": 10, <1>
-        "query" : {
-            "term" : {
-                "tag" : "something"
+    "query": {
+        "has_child" : {
+            "type" : "blog_tag",
+            "score_mode" : "min",
+            "min_children": 2, <1>
+            "max_children": 10, <1>
+            "query" : {
+                "term" : {
+                    "tag" : "something"
+                }
             }
         }
     }
 }
 --------------------------------------------------
+// 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,17 +9,21 @@ in the same manner as the `has_child` query.
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "has_parent" : {
-        "parent_type" : "blog",
-        "query" : {
-            "term" : {
-                "tag" : "something"
-            }
+    "query": {
+        "has_parent" : {
+            "parent_type" : "blog",
+                "query" : {
+                    "term" : {
+                        "tag" : "something"
+                    }
+                }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [float]
 ==== Scoring capabilities
@@ -34,18 +38,22 @@ matching parent document. The score mode can be specified with the
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "has_parent" : {
-        "parent_type" : "blog",
-        "score" : true,
-        "query" : {
-            "term" : {
-                "tag" : "something"
-            }
+    "query": {
+        "has_parent" : {
+            "parent_type" : "blog",
+                "score" : true,
+                "query" : {
+                    "term" : {
+                        "tag" : "something"
+                    }
+                }
         }
     }
 }
 --------------------------------------------------
+// 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
 {
-    "ids" : {
-        "type" : "my_type",
-        "values" : ["1", "4", "100"]
+    "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
 {
-    "indices" : {
-        "indices" : ["index1", "index2"],
-        "query" : {
-            "term" : { "tag" : "wow" }
-        },
-        "no_match_query" : {
-            "term" : { "tag" : "kow" }
+    "query": {
+        "indices" : {
+            "indices" : ["index1", "index2"],
+            "query" : { "term" : { "tag" : "wow" } },
+            "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
 {
-    "match_phrase_prefix" : {
-        "message" : "quick brown f"
+    "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,15 +25,19 @@ example:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "match_phrase_prefix" : {
-        "message" : {
-            "query" : "quick brown f",
-            "max_expansions" : 10
+    "query": {
+        "match_phrase_prefix" : {
+            "message" : {
+                "query" : "quick brown f",
+                "max_expansions" : 10
+            }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [IMPORTANT]
 ===================================================
@@ -53,4 +61,4 @@ For better solutions for _search-as-you-type_ see the
 <<search-suggesters-completion,completion suggester>> and
 {guide}/_index_time_search_as_you_type.html[Index-Time Search-as-You-Type].
 
-===================================================
+===================================================

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

@@ -6,12 +6,16 @@ out of the analyzed text. For example:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "match_phrase" : {
-        "message" : "this is a test"
+    "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,12 +26,16 @@ definition, or the default search analyzer, for example:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "match_phrase" : {
-        "message" : {
-            "query" : "this is a test",
-            "analyzer" : "my_analyzer"
+    "query": {
+        "match_phrase" : {
+            "message" : {
+                "query" : "this is a test",
+                "analyzer" : "my_analyzer"
+            }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE

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

@@ -7,12 +7,16 @@ them, and constructs a query. For example:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "match" : {
-        "message" : "this is a test"
+    "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,15 +61,19 @@ change in structure, `message` is the field name):
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "match" : {
-        "message" : {
-            "query" : "this is a test",
-            "operator" : "and"
+    "query": {
+        "match" : {
+            "message" : {
+                "query" : "this is a test",
+                "operator" : "and"
+            }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [[query-dsl-match-query-zero]]
 ===== Zero terms query
@@ -76,16 +84,20 @@ change that the `zero_terms_query` option can be used, which accepts
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "match" : {
-        "message" : {
-            "query" : "to be or not to be",
-            "operator" : "and",
-            "zero_terms_query": "all"
+    "query": {
+        "match" : {
+            "message" : {
+                "query" : "to be or not to be",
+                "operator" : "and",
+                "zero_terms_query": "all"
+            }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 [[query-dsl-match-query-cutoff]]
 ===== Cutoff frequency
@@ -113,16 +125,19 @@ Here is an example showing a query composed of stopwords exclusively:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "match" : {
-        "message" : {
-            "query" : "to be or not to be",
-            "cutoff_frequency" : 0.001
+    "query": {
+        "match" : {
+            "message" : {
+                "query" : "to be or not to be",
+                "cutoff_frequency" : 0.001
+            }
         }
     }
 }
 --------------------------------------------------
-
+// 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,15 +15,19 @@ fields, limiting the number of selected terms to 12.
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "more_like_this" : {
-        "fields" : ["title", "description"],
-        "like" : "Once upon a time",
-        "min_term_freq" : 1,
-        "max_query_terms" : 12
+    "query": {
+        "more_like_this" : {
+            "fields" : ["title", "description"],
+            "like" : "Once upon a time",
+            "min_term_freq" : 1,
+            "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,27 +35,31 @@ similar to the one used in the <<docs-multi-get,Multi GET API>>.
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "more_like_this" : {
-        "fields" : ["title", "description"],
-        "like" : [
-        {
-            "_index" : "imdb",
-            "_type" : "movies",
-            "_id" : "1"
-        },
-        {
-            "_index" : "imdb",
-            "_type" : "movies",
-            "_id" : "2"
-        },
-        "and potentially some more text here as well"
-        ],
-        "min_term_freq" : 1,
-        "max_query_terms" : 12
+    "query": {
+        "more_like_this" : {
+            "fields" : ["title", "description"],
+            "like" : [
+            {
+                "_index" : "imdb",
+                "_type" : "movies",
+                "_id" : "1"
+            },
+            {
+                "_index" : "imdb",
+                "_type" : "movies",
+                "_id" : "2"
+            },
+            "and potentially some more text here as well"
+            ],
+            "min_term_freq" : 1,
+            "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,32 +67,36 @@ present in the index, the syntax is similar to <<docs-termvectors-artificial-doc
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "more_like_this" : {
-        "fields" : ["name.first", "name.last"],
-        "like" : [
-        {
-            "_index" : "marvel",
-            "_type" : "quotes",
-            "doc" : {
-                "name": {
-                    "first": "Ben",
-                    "last": "Grimm"
-                },
-                "tweet": "You got no idea what I'd... what I'd give to be invisible."
-              }
-        },
-        {
-            "_index" : "marvel",
-            "_type" : "quotes",
-            "_id" : "2"
+    "query": {
+        "more_like_this" : {
+            "fields" : ["name.first", "name.last"],
+            "like" : [
+            {
+                "_index" : "marvel",
+                "_type" : "quotes",
+                "doc" : {
+                    "name": {
+                        "first": "Ben",
+                        "last": "Grimm"
+                    },
+                    "tweet": "You got no idea what I'd... what I'd give to be invisible."
+                  }
+            },
+            {
+                "_index" : "marvel",
+                "_type" : "quotes",
+                "_id" : "2"
+            }
+            ],
+            "min_term_freq" : 1,
+            "max_query_terms" : 12
         }
-        ],
-        "min_term_freq" : 1,
-        "max_query_terms" : 12
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 ==== How it Works
 
@@ -111,32 +123,34 @@ default, but there will be no speed up on analysis for these fields.
 
 [source,js]
 --------------------------------------------------
-curl -s -XPUT 'http://localhost:9200/imdb/' -d '{
-  "mappings": {
-    "movies": {
-      "properties": {
-        "title": {
-          "type": "text",
-          "term_vector": "yes"
-         },
-         "description": {
-          "type": "text"
-        },
-        "tags": {
-          "type": "text",
-          "fields" : {
-            "raw": {
-              "type" : "text",
-              "analyzer": "keyword",
-              "term_vector" : "yes"
+PUT /imdb
+{
+    "mappings": {
+        "movies": {
+            "properties": {
+                "title": {
+                    "type": "text",
+                    "term_vector": "yes"
+                },
+                "description": {
+                    "type": "text"
+                },
+                "tags": {
+                    "type": "text",
+                    "fields" : {
+                        "raw": {
+                            "type" : "text",
+                            "analyzer": "keyword",
+                            "term_vector" : "yes"
+                        }
+                    }
+                }
             }
-          }
         }
-      }
     }
-  }
 }
 --------------------------------------------------
+// CONSOLE
 
 ==== Parameters
 

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

@@ -6,13 +6,17 @@ to allow multi-field queries:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "multi_match" : {
-    "query":    "this is a test", <1>
-    "fields": [ "subject", "message" ] <2>
+  "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
 {
-  "multi_match" : {
-    "query":    "Will Smith",
-    "fields": [ "title", "*_name" ] <1>
+  "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
 {
-  "multi_match" : {
-    "query" : "this is a test",
-    "fields" : [ "subject^3", "message" ] <1>
+  "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,30 +95,38 @@ find the single best matching field.  For instance, this query:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "multi_match" : {
-    "query":      "brown fox",
-    "type":       "best_fields",
-    "fields":     [ "subject", "message" ],
-    "tie_breaker": 0.3
+  "query": {
+    "multi_match" : {
+      "query":      "brown fox",
+      "type":       "best_fields",
+      "fields":     [ "subject", "message" ],
+      "tie_breaker": 0.3
+    }
   }
 }
 --------------------------------------------------
+// CONSOLE
 
 would be executed as:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "dis_max": {
-    "queries": [
-      { "match": { "subject": "brown fox" }},
-      { "match": { "message": "brown fox" }}
-    ],
-    "tie_breaker": 0.3
+  "query": {
+    "dis_max": {
+      "queries": [
+        { "match": { "subject": "brown fox" }},
+        { "match": { "message": "brown fox" }}
+      ],
+      "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,15 +153,20 @@ Take this query for example:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "multi_match" : {
-    "query":      "Will Smith",
-    "type":       "best_fields",
-    "fields":     [ "first_name", "last_name" ],
-    "operator":   "and" <1>
+  "query": {
+    "multi_match" : {
+      "query":      "Will Smith",
+      "type":       "best_fields",
+      "fields":     [ "first_name", "last_name" ],
+      "operator":   "and" <1>
+    }
   }
 }
 --------------------------------------------------
+// CONSOLE
+
 <1> All terms must be present.
 
 This query is executed as:
@@ -170,29 +196,37 @@ This query:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "multi_match" : {
-    "query":      "quick brown fox",
-    "type":       "most_fields",
-    "fields":     [ "title", "title.original", "title.shingles" ]
+  "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
 {
-  "bool": {
-    "should": [
-      { "match": { "title":          "quick brown fox" }},
-      { "match": { "title.original": "quick brown fox" }},
-      { "match": { "title.shingles": "quick brown fox" }}
-    ]
+  "query": {
+    "bool": {
+      "should": [
+        { "match": { "title":          "quick brown fox" }},
+        { "match": { "title.original": "quick brown fox" }},
+        { "match": { "title.shingles": "quick brown fox" }}
+      ]
+    }
   }
 }
 --------------------------------------------------
+// CONSOLE
 
 The score from each `match` clause is added together, then divided by the
 number of `match` clauses.
@@ -212,28 +246,36 @@ but they use a `match_phrase` or `match_phrase_prefix` query instead of a
 This query:
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "multi_match" : {
-    "query":      "quick brown f",
-    "type":       "phrase_prefix",
-    "fields":     [ "subject", "message" ]
+  "query": {
+    "multi_match" : {
+      "query":      "quick brown f",
+      "type":       "phrase_prefix",
+      "fields":     [ "subject", "message" ]
+    }
   }
 }
 --------------------------------------------------
+// CONSOLE
 
 would be executed as:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "dis_max": {
-    "queries": [
-      { "match_phrase_prefix": { "subject": "quick brown f" }},
-      { "match_phrase_prefix": { "message": "quick brown f" }}
-    ]
+  "query": {
+    "dis_max": {
+      "queries": [
+        { "match_phrase_prefix": { "subject": "quick brown f" }},
+        { "match_phrase_prefix": { "message": "quick brown f" }}
+      ]
+    }
   }
 }
 --------------------------------------------------
+// CONSOLE
 
 Also, accepts `analyzer`, `boost`, `slop` and `zero_terms_query`  as explained
 in <<query-dsl-match-query>>.  Type `phrase_prefix` additionally accepts
@@ -288,15 +330,19 @@ A query like:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "multi_match" : {
-    "query":      "Will Smith",
-    "type":       "cross_fields",
-    "fields":     [ "first_name", "last_name" ],
-    "operator":   "and"
+  "query": {
+    "multi_match" : {
+      "query":      "Will Smith",
+      "type":       "cross_fields",
+      "fields":     [ "first_name", "last_name" ],
+      "operator":   "and"
+    }
   }
 }
 --------------------------------------------------
+// CONSOLE
 
 is executed as:
 
@@ -344,17 +390,21 @@ both use an `edge_ngram` analyzer, this query:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "multi_match" : {
-    "query":      "Jon",
-    "type":       "cross_fields",
-    "fields":     [
+  "query": {
+    "multi_match" : {
+      "query":      "Jon",
+      "type":       "cross_fields",
+      "fields":     [
         "first", "first.edge",
         "last",  "last.edge"
-    ]
+      ]
+    }
   }
 }
 --------------------------------------------------
+// CONSOLE
 
 would be executed as:
 
@@ -379,28 +429,33 @@ parameter to just one of them:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
+  "query": {
     "bool": {
-        "should": [
-            {
-              "multi_match" : {
-                "query":      "Will Smith",
-                "type":       "cross_fields",
-                "fields":     [ "first", "last" ],
-                "minimum_should_match": "50%" <1>
-              }
-            },
-            {
-              "multi_match" : {
-                "query":      "Will Smith",
-                "type":       "cross_fields",
-                "fields":     [ "*.edge" ]
-              }
-            }
-        ]
+      "should": [
+        {
+          "multi_match" : {
+            "query":      "Will Smith",
+            "type":       "cross_fields",
+            "fields":     [ "first", "last" ],
+            "minimum_should_match": "50%" <1>
+          }
+        },
+        {
+          "multi_match" : {
+            "query":      "Will Smith",
+            "type":       "cross_fields",
+            "fields":     [ "*.edge" ]
+          }
+        }
+      ]
     }
+  }
 }
 --------------------------------------------------
+// CONSOLE 
+
 <1> Either `will` or `smith` must be present in either of the `first`
     or `last` fields
 
@@ -409,15 +464,20 @@ parameter in the query.
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-  "multi_match" : {
-    "query":      "Jon",
-    "type":       "cross_fields",
-    "analyzer":   "standard", <1>
-    "fields":     [ "first", "last", "*.edge" ]
+  "query": {
+   "multi_match" : {
+      "query":      "Jon",
+      "type":       "cross_fields",
+      "analyzer":   "standard", <1>
+      "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,40 +10,45 @@ will work with:
 
 [source,js]
 --------------------------------------------------
+PUT /my_index
 {
-    "type1" : {
-        "properties" : {
-            "obj1" : {
-                "type" : "nested"
+    "mappings": {
+        "type1" : {
+            "properties" : {
+                "obj1" : {
+                    "type" : "nested"
+                }
             }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
+// TESTSETUP
 
 And here is a sample nested query usage:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "nested" : {
-        "path" : "obj1",
-        "score_mode" : "avg",
-        "query" : {
-            "bool" : {
-                "must" : [
-                    {
-                        "match" : {"obj1.name" : "blue"}
-                    },
-                    {
-                        "range" : {"obj1.count" : {"gt" : 5}}
-                    }
-                ]
+    "query": {
+        "nested" : {
+            "path" : "obj1",
+            "score_mode" : "avg",
+            "query" : {
+                "bool" : {
+                    "must" : [
+                    { "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

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

@@ -54,17 +54,21 @@ better as it does not need to do a join:
 
 [source,js]
 --------------------------------------------------
+GET /my_index/_search
 {
-  "has_parent": {
-    "type": "blog",
-    "query": {
-      "term": {
-        "_id": "1"
+  "query": {
+    "has_parent": {
+      "type": "blog_post",
+        "query": {
+          "term": {
+            "_id": "1"
+        }
       }
     }
   }
 }
 --------------------------------------------------
+// CONSOLE
 
 ==== Parameters
 

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

@@ -13,26 +13,27 @@ Create an index with two mappings:
 
 [source,js]
 --------------------------------------------------
-curl -XPUT "http://localhost:9200/my-index" -d'
+PUT /my-index
 {
-  "mappings": {
-    "doctype": {
-      "properties": {
-        "message": {
-          "type": "string"
-        }
-      }
-    },
-    "queries": {
-      "properties": {
-        "query": {
-          "type": "percolator"
+    "mappings": {
+        "doctype": {
+            "properties": {
+                "message": {
+                    "type": "string"
+                }
+            }
+        },
+        "queries": {
+            "properties": {
+                "query": {
+                    "type": "percolator"
+                }
+            }
         }
-      }
     }
-  }
-}'
+}
 --------------------------------------------------
+// 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_string" : {
-        "default_field" : "content",
-        "query" : "this AND that OR thus"
+    "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_string" : {
-        "fields" : ["content", "name"],
-        "query" : "this AND that"
+    "query": {
+        "query_string" : {
+            "fields" : ["content", "name"],
+            "query" : "this AND that"
+        }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 matches the same words as
 
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "query_string": {
-      "query": "(content:this OR name:this) AND (content:that OR name:that)"
+    "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_string" : {
-        "fields" : ["content", "name^5"],
-        "query" : "this AND that OR thus",
-        "use_dis_max" : true
+    "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_string" : {
-        "fields" : ["city.*"],
-        "query" : "this AND that OR thus",
-        "use_dis_max" : true
+    "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_string" : {
-        "fields" : ["content", "name.*^5"],
-        "query" : "this AND that OR thus",
-        "use_dis_max" : true
+    "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,16 +9,20 @@ a `NumericRangeQuery`. The following example returns all documents where
 
 [source,js]
 --------------------------------------------------
+GET _search
 {
-    "range" : {
-        "age" : {
-            "gte" : 10,
-            "lte" : 20,
-            "boost" : 2.0
+    "query": {
+        "range" : {
+            "age" : {
+                "gte" : 10,
+                "lte" : 20,
+                "boost" : 2.0
+            }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE 
 
 The `range` query accepts the following parameters:
 
@@ -38,15 +42,19 @@ specified using <<date-math>>:
 
 [source,js]
 --------------------------------------------------
+GET _search
 {
-    "range" : {
-        "date" : {
-            "gte" : "now-1d/d",
-            "lt" :  "now/d"
+    "query": {
+        "range" : {
+            "date" : {
+                "gte" : "now-1d/d",
+                "lt" :  "now/d"
+            }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 ===== Date math and rounding
 
@@ -86,16 +94,20 @@ passing the `format` parameter to the `range` query:
 
 [source,js]
 --------------------------------------------------
+GET _search
 {
-    "range" : {
-        "born" : {
-            "gte": "01/01/2012",
-            "lte": "2013",
-            "format": "dd/MM/yyyy||yyyy"
+    "query": {
+        "range" : {
+            "born" : {
+                "gte": "01/01/2012",
+                "lte": "2013",
+                "format": "dd/MM/yyyy||yyyy"
+            }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE 
 
 ===== Time zone in range queries
 
@@ -105,15 +117,19 @@ accepts it), or it can be specified as the `time_zone` parameter:
 
 [source,js]
 --------------------------------------------------
+GET _search
 {
-    "range" : {
-        "timestamp" : {
-            "gte": "2015-01-01 00:00:00", <1>
-            "lte": "now", <2>
-            "time_zone": "+01:00"
+    "query": {
+        "range" : {
+            "timestamp" : {
+                "gte": "2015-01-01 00:00:00", <1>
+                "lte": "now", <2>
+                "time_zone": "+01:00"
+            }
         }
     }
 }
 --------------------------------------------------
+// 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,40 +15,52 @@ matchers like `.*?+` will mostly lower performance.
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "regexp":{
-        "name.first": "s.*y"
+    "query": {
+        "regexp":{
+            "name.first": "s.*y"
+        }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 Boosting is also supported
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "regexp":{
-        "name.first":{
-            "value":"s.*y",
-            "boost":1.2
+    "query": {
+        "regexp":{
+            "name.first":{
+                "value":"s.*y",
+                "boost":1.2
+            }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 You can also use special flags
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "regexp":{
-        "name.first": {
-            "value": "s.*y",
-            "flags" : "INTERSECTION|COMPLEMENT|EMPTY"
+    "query": {
+        "regexp":{
+            "name.first": {
+                "value": "s.*y",
+                "flags" : "INTERSECTION|COMPLEMENT|EMPTY"
+            }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 Possible flags are `ALL` (default), `ANYSTRING`, `COMPLEMENT`,
 `EMPTY`, `INTERSECTION`, `INTERVAL`, or `NONE`. Please check the
@@ -64,16 +76,19 @@ this limit to allow more complex regular expressions to execute.
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "regexp":{
-        "name.first": {
-            "value": "s.*y",
-            "flags" : "INTERSECTION|COMPLEMENT|EMPTY",
-	    "max_determinized_states": 20000
+    "query": {
+        "regexp":{
+            "name.first": {
+                "value": "s.*y",
+                "flags" : "INTERSECTION|COMPLEMENT|EMPTY",
+                "max_determinized_states": 20000
+            }
         }
     }
 }
 --------------------------------------------------
-
+// CONSOLE
 
 include::regexp-syntax.asciidoc[]

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

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

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

@@ -8,15 +8,19 @@ an example:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
+  "query": {
     "simple_query_string" : {
         "query": "\"fried eggs\" +(eggplant | potato) -frittata",
         "analyzer": "snowball",
         "fields": ["body^5","_all"],
         "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
 {
-    "simple_query_string" : {
-        "fields" : ["content", "name.*^5"],
-        "query" : "foo bar baz"
+    "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
 {
-    "simple_query_string" : {
-        "query" : "foo | bar + baz*",
-        "flags" : "OR|AND|PREFIX"
+    "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,24 +6,28 @@ query maps to Lucene `SpanContainingQuery`. Here is an example:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "span_containing" : {
-        "little" : {
-            "span_term" : { "field1" : "foo" }
-        },
-        "big" : {
-            "span_near" : { 
-                "clauses" : [
-                    { "span_term" : { "field1" : "bar" } },
-                    { "span_term" : { "field1" : "baz" } }
-                ],
-                "slop" : 5,
-                "in_order" : true
+    "query": {
+        "span_containing" : {
+            "little" : {
+                "span_term" : { "field1" : "foo" }
+            },
+            "big" : {
+                "span_near" : { 
+                    "clauses" : [
+                        { "span_term" : { "field1" : "bar" } },
+                        { "span_term" : { "field1" : "baz" } }
+                    ],
+                    "slop" : 5,
+                    "in_order" : true
+                }
             }
         }
     }
 }
 --------------------------------------------------
+//  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,15 +6,19 @@ to Lucene `SpanFirstQuery`. Here is an example:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "span_first" : {
-        "match" : {
-            "span_term" : { "user" : "kimchy" }
-        },
-        "end" : 3
+    "query": {
+        "span_first" : {
+            "match" : {
+                "span_term" : { "user" : "kimchy" }
+            },
+            "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
 {
-    "span_multi":{
-        "match":{
-            "prefix" : { "user" :  { "value" : "ki" } }
+    "query": {
+        "span_multi":{
+            "match":{
+                "prefix" : { "user" :  { "value" : "ki" } }
+            }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE
 
 A boost can also be associated with the query:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "span_multi":{
-        "match":{
-            "prefix" : { "user" :  { "value" : "ki", "boost" : 1.08 } }
+    "query": {
+        "span_multi":{
+            "match":{
+                "prefix" : { "user" :  { "value" : "ki", "boost" : 1.08 } }
+            }
         }
     }
 }
 --------------------------------------------------
+// CONSOLE

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

@@ -8,18 +8,22 @@ matches are required to be in-order. The span near query maps to Lucene
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "span_near" : {
-        "clauses" : [
-            { "span_term" : { "field" : "value1" } },
-            { "span_term" : { "field" : "value2" } },
-            { "span_term" : { "field" : "value3" } }
-        ],
-        "slop" : 12,
-        "in_order" : false
+    "query": {
+        "span_near" : {
+            "clauses" : [
+                { "span_term" : { "field" : "value1" } },
+                { "span_term" : { "field" : "value2" } },
+                { "span_term" : { "field" : "value3" } }
+            ],
+            "slop" : 12,
+            "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,24 +6,28 @@ query maps to Lucene `SpanNotQuery`. Here is an example:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "span_not" : {
-        "include" : {
-            "span_term" : { "field1" : "hoya" }
-        },
-        "exclude" : {
-            "span_near" : { 
-                "clauses" : [
-                    { "span_term" : { "field1" : "la" } },
-                    { "span_term" : { "field1" : "hoya" } }
-                ],
-                "slop" : 0,
-                "in_order" : true
+    "query": {
+        "span_not" : {
+            "include" : {
+                "span_term" : { "field1" : "hoya" }
+            },
+            "exclude" : {
+                "span_near" : { 
+                    "clauses" : [
+                        { "span_term" : { "field1" : "la" } },
+                        { "span_term" : { "field1" : "hoya" } }
+                    ],
+                    "slop" : 0,
+                    "in_order" : true
+                }
             }
         }
     }
 }
 --------------------------------------------------
+// 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,15 +6,19 @@ Matches the union of its span clauses. The span or query maps to Lucene
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "span_or" : {
-        "clauses" : [
-            { "span_term" : { "field" : "value1" } },
-            { "span_term" : { "field" : "value2" } },
-            { "span_term" : { "field" : "value3" } }
-        ]
+    "query": {
+        "span_or" : {
+            "clauses" : [
+                { "span_term" : { "field" : "value1" } },
+                { "span_term" : { "field" : "value2" } },
+                { "span_term" : { "field" : "value3" } }
+            ]
+        }
     }
 }
 --------------------------------------------------
+// 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
 {
-    "span_term" : { "user" : "kimchy" }
+    "query": {
+        "span_term" : { "user" : "kimchy" }
+    }
 }    
 --------------------------------------------------
+// CONSOLE
 
 A boost can also be associated with the query:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "span_term" : { "user" : { "value" : "kimchy", "boost" : 2.0 } }
+    "query": {
+       "span_term" : { "user" : { "value" : "kimchy", "boost" : 2.0 } }
+    }
 }    
 --------------------------------------------------
+// CONSOLE
 
 Or :
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "span_term" : { "user" : { "term" : "kimchy", "boost" : 2.0 } }
+    "query": {
+        "span_term" : { "user" : { "term" : "kimchy", "boost" : 2.0 } }
+    }
 }    
 --------------------------------------------------
+// CONSOLE

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

@@ -6,24 +6,28 @@ query maps to Lucene `SpanWithinQuery`. Here is an example:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "span_within" : {
-        "little" : {
-            "span_term" : { "field1" : "foo" }
-        },
-        "big" : {
-            "span_near" : { 
-                "clauses" : [
-                    { "span_term" : { "field1" : "bar" } },
-                    { "span_term" : { "field1" : "baz" } }
-                ],
-                "slop" : 5,
-                "in_order" : true
+    "query": {
+        "span_within" : {
+            "little" : {
+                "span_term" : { "field1" : "foo" }
+            },
+            "big" : {
+                "span_near" : { 
+                    "clauses" : [
+                        { "span_term" : { "field1" : "bar" } },
+                        { "span_term" : { "field1" : "baz" } }
+                    ],
+                    "slop" : 5,
+                    "in_order" : true
+                }
             }
         }
     }
 }
 --------------------------------------------------
+// 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
 {
-    "constant_score" : {
-        "filter" : {
-            "terms" : { "user" : ["kimchy", "elasticsearch"]}
+    "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,33 +67,37 @@ 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 '{
-   "followers" : ["1", "3"]
-}'
+PUT /users/user/2
+{
+    "followers" : ["1", "3"]
+}
 
-# index a tweet, from user with id 1
-curl -XPUT localhost:9200/tweets/tweet/1 -d '{
-   "user" : "1"
-}'
+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 '{
-  "query" : {
-    "terms" : {
-      "user" : {
-        "index" : "users",
-        "type" : "user",
-        "id" : "2",
-        "path" : "followers"
-      }
+GET /tweets/_search
+{
+    "query" : {
+        "terms" : {
+            "user" : {
+                "index" : "users",
+                "type" : "user",
+                "id" : "2",
+                "path" : "followers"
+            }
+        }
     }
-  }
-}'
+}
 --------------------------------------------------
+// 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
 {
-    "type" : {
-        "value" : "my_type"
+    "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
 {
-    "wildcard" : { "user" : "ki*y" }
+    "query": {
+        "wildcard" : { "user" : "ki*y" }
+    }
 }
 --------------------------------------------------
+// CONSOLE
 
 A boost can also be associated with the query:
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "wildcard" : { "user" : { "value" : "ki*y", "boost" : 2.0 } }
+    "query": {
+        "wildcard" : { "user" : { "value" : "ki*y", "boost" : 2.0 } }
+    }
 }
 --------------------------------------------------
+// CONSOLE
 
 Or :
 
 [source,js]
 --------------------------------------------------
+GET /_search
 {
-    "wildcard" : { "user" : { "wildcard" : "ki*y", "boost" : 2.0 } }
+    "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>>