matchQuery(
        "name", (1)
        "kimchy elasticsearch"); (2)

multiMatchQuery(
        "kimchy elasticsearch", (1)
        "user", "message"); (2)

commonTermsQuery("name", (1)
                 "kimchy"); (2)

queryStringQuery("+kimchy -elasticsearch");

simpleQueryStringQuery("+kimchy -elasticsearch");

termQuery(
        "name", (1)
        "kimchy"); (2)

termsQuery("tags", (1)
        "blue", "pill"); (2)

rangeQuery("price") (1)
    .from(5) (2)
    .to(10) (3)
    .includeLower(true) (4)
    .includeUpper(false);  (5)

// 一种简单的写法是使用 gte(greater than or equal), gt, lt 或 lte(less than or equal)
rangeQuery("age") (1)
    .gte("10") (2)
    .lt("20"); (3)

existsQuery("name"); (1)

prefixQuery(
        "brand", (1)
        "heine"); (2)

wildcardQuery(
        "user", (1)
        "k?mch*"); (2)

regexpQuery(
        "name.first", (1)
        "s.*y"); (2)

fuzzyQuery(
        "name", (1)
        "kimchy"); (2)

typeQuery("my_type"); (1)

idsQuery("my_type", "type2")
        .addIds("1", "4", "100");

idsQuery() (1)
        .addIds("1", "4", "100");

constantScoreQuery(
        termQuery("name","kimchy")) (1)
    .boost(2.0f); (2)

boolQuery()
        .must(termQuery("content", "test1")) (1)
        .must(termQuery("content", "test4")) (1)
        .mustNot(termQuery("content", "test2")) (2)
        .should(termQuery("content", "test3")) (3)
        .filter(termQuery("content", "test5"));  (4)

disMaxQuery()
        .add(termQuery("name", "kimchy")) (1)
        .add(termQuery("name", "elasticsearch")) (2)
        .boost(1.2f) (3)
        .tieBreaker(0.7f); (4)

import static org.elasticsearch.index.query.functionscore.ScoreFunctionBuilders.*;

FilterFunctionBuilder[] functions = {
        new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                matchQuery("name", "kimchy"), (1)
                randomFunction()), (2)
        new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                exponentialDecayFunction("age", 0L, 1L)) (3)
};
functionScoreQuery(functions);

boostingQuery(
            termQuery("name","kimchy"), (1)
            termQuery("name","dadoonet")) (2)
        .negativeBoost(0.2f); (3)

nestedQuery(
        "obj1", (1)
        boolQuery() (2)
                .must(matchQuery("obj1.name", "blue"))
                .must(rangeQuery("obj1.count").gt(5)),
        ScoreMode.Avg); (3)

Settings settings = Settings.builder().put("cluster.name", "elasticsearch").build();
TransportClient client = new PreBuiltTransportClient(settings);
client.addTransportAddress(new TransportAddress(new InetSocketAddress(InetAddresses.forString("127.0.0.1"), 9300)));

JoinQueryBuilders.hasChildQuery(
        "blog_tag", (1)
        termQuery("tag","something"), (2)
        ScoreMode.None); (3)

Settings settings = Settings.builder().put("cluster.name", "elasticsearch").build();
TransportClient client = new PreBuiltTransportClient(settings);
client.addTransportAddress(new TransportAddress(new InetSocketAddress(InetAddresses.forString("127.0.0.1"), 9300)));

JoinQueryBuilders.hasParentQuery(
    "blog", (1)
    termQuery("tag","something"), (2)
    false); (3)

<dependency>
    <groupId>org.locationtech.spatial4j</groupId>
    <artifactId>spatial4j</artifactId>
    <version>0.7</version>  (1)
</dependency>

<dependency>
    <groupId>org.locationtech.jts</groupId>
    <artifactId>jts-core</artifactId>
    <version>1.15.0</version> (2)
    <exclusions>
        <exclusion>
            <groupId>xerces</groupId>
            <artifactId>xercesImpl</artifactId>
        </exclusion>
    </exclusions>
</dependency>

// Import ShapeRelation and ShapeBuilder
import org.elasticsearch.common.geo.ShapeRelation;
import org.elasticsearch.common.geo.builders.ShapeBuilder;

GeoShapeQueryBuilder qb = geoShapeQuery(
        "pin.location", (1)
        new MultiPointBuilder( (2)
                new CoordinatesBuilder()
            .coordinate(0, 0)
            .coordinate(0, 10)
            .coordinate(10, 10)
            .coordinate(10, 0)
            .coordinate(0, 0)
            .build()));
qb.relation(ShapeRelation.WITHIN); (3)

// Using pre-indexed shapes
GeoShapeQueryBuilder qb = geoShapeQuery(
            "pin.location", (1)
            "DEU", (2)
            "countries"); (3)
qb.relation(ShapeRelation.WITHIN) (4)
    .indexedShapeIndex("shapes") (5)
    .indexedShapePath("location");  (6)

geoBoundingBoxQuery("pin.location") (1)
    .setCorners(40.73, -74.1, (2)
                40.717, -73.99); (3)

geoDistanceQuery("pin.location") (1)
    .point(40, -70) (2)
    .distance(200, DistanceUnit.KILOMETERS); (3)

List<GeoPoint> points = new ArrayList<GeoPoint>(); (1)
points.add(new GeoPoint(40, -70));
points.add(new GeoPoint(30, -80));
points.add(new GeoPoint(20, -90));
geoPolygonQuery("pin.location", points); (2)

String[] fields = {"name.first", "name.last"}; (1)
String[] texts = {"text like this one"}; (2)

moreLikeThisQuery(fields, texts, null)
    .minTermFreq(1) (3)
    .maxQueryTerms(12); (4)

scriptQuery(
        new Script("doc['num1'].value > 1") (1)
    );

doc['num1'].value > params.param1

Map<String, Object> parameters = new HashMap<>();
parameters.put("param1", 5);
scriptQuery(new Script(
        ScriptType.STORED, (1)
        null, (2)
        "myscript", (3)
        singletonMap("param1", 5))); (4)

Settings settings = Settings.builder().put("cluster.name", "elasticsearch").build();
TransportClient client = new PreBuiltTransportClient(settings);
client.addTransportAddress(new TransportAddress(new InetSocketAddress(InetAddresses.forString("127.0.0.1"), 9300)));

// create an index with a percolator field with the name 'query':
client.admin().indices().prepareCreate("myIndexName")
                        .addMapping("_doc", "query", "type=percolator", "content", "type=text")
                        .get();

//This is the query we're registering in the percolator
QueryBuilder qb = termQuery("content", "amazing");

//Index the query = register it in the percolator
client.prepareIndex("myIndexName", "_doc", "myDesignatedQueryName")
    .setSource(jsonBuilder()
        .startObject()
            .field("query", qb) // Register the query
        .endObject())
    .setRefreshPolicy(RefreshPolicy.IMMEDIATE) // Needed when the query shall be available immediately
    .get();

//Build a document to check against the percolator
XContentBuilder docBuilder = XContentFactory.jsonBuilder().startObject();
docBuilder.field("content", "This is amazing!");
docBuilder.endObject(); //End of the JSON root object

PercolateQueryBuilder percolateQuery = new PercolateQueryBuilder("query", "_doc", BytesReference.bytes(docBuilder));

// Percolate, by executing the percolator query in the query dsl:
SearchResponse response = client().prepareSearch("myIndexName")
        .setQuery(percolateQuery))
        .get();
//Iterate over the results
for(SearchHit hit : response.getHits()) {
    // Percolator queries as hit
}

String query = "{\"term\": {\"user\": \"kimchy\"}}"; (1)
wrapperQuery(query);

spanTermQuery(
        "user",  (1)
        "kimchy");  (2)

spanMultiTermQueryBuilder(
        prefixQuery("user", "ki")); (1)

spanFirstQuery(
        spanTermQuery("user", "kimchy"), (1)
        3 (2)
    );

spanNearQuery(
        spanTermQuery("field","value1"), (1)
        12) (2)
            .addClause(spanTermQuery("field","value2")) (3)
            .addClause(spanTermQuery("field","value3")) (4)
            .inOrder(false); (5)

spanOrQuery(spanTermQuery("field","value1")) (1)
    .addClause(spanTermQuery("field","value2")) (2)
    .addClause(spanTermQuery("field","value3")); (3)

spanNotQuery(
        spanTermQuery("field","value1"), (1)
        spanTermQuery("field","value2")); (2)

spanContainingQuery(
        spanNearQuery(spanTermQuery("field1","bar"), 5) (1)
            .addClause(spanTermQuery("field1","baz"))
            .inOrder(true),
        spanTermQuery("field1","foo")); (2)

spanWithinQuery(
        spanNearQuery(spanTermQuery("field1", "bar"), 5) (1)
            .addClause(spanTermQuery("field1", "baz"))
            .inOrder(true),
        spanTermQuery("field1", "foo")); (2)