Java 类org.elasticsearch.index.query.MoreLikeThisQueryBuilder 实例源码

public void testThatMoreLikeThisQueryMultiTermVectorRequestContainsContextAndHeaders() throws Exception {
    transportClient().prepareIndex(lookupIndex, "type", "1")
        .setSource(jsonBuilder().startObject().field("name", "Star Wars - The new republic").endObject())
        .get();
    transportClient().prepareIndex(queryIndex, "type", "1")
        .setSource(jsonBuilder().startObject().field("name", "Jar Jar Binks - A horrible mistake").endObject())
        .get();
    transportClient().prepareIndex(queryIndex, "type", "2")
        .setSource(jsonBuilder().startObject().field("name", "Star Wars - Return of the jedi").endObject())
        .get();
    transportClient().admin().indices().prepareRefresh(lookupIndex, queryIndex).get();

    MoreLikeThisQueryBuilder moreLikeThisQueryBuilder = QueryBuilders.moreLikeThisQuery(new String[]{"name"}, null,
        new Item[]{new Item(lookupIndex, "type", "1")})
        .minTermFreq(1)
        .minDocFreq(1);

    SearchResponse searchResponse = transportClient()
        .prepareSearch(queryIndex)
        .setQuery(moreLikeThisQueryBuilder)
        .get();
    assertNoFailures(searchResponse);
    assertHitCount(searchResponse, 1);

    assertRequestsContainHeader(MultiTermVectorsRequest.class);
}

public void testSimpleMoreLikeThis() throws Exception {
    logger.info("Creating index test");
    assertAcked(prepareCreate("test").addMapping("type1",
            jsonBuilder().startObject().startObject("type1").startObject("properties")
                    .startObject("text").field("type", "text").endObject()
                    .endObject().endObject().endObject()));

    logger.info("Running Cluster Health");
    assertThat(ensureGreen(), equalTo(ClusterHealthStatus.GREEN));

    logger.info("Indexing...");
    client().index(indexRequest("test").type("type1").id("1").source(jsonBuilder().startObject().field("text", "lucene").endObject())).actionGet();
    client().index(indexRequest("test").type("type1").id("2").source(jsonBuilder().startObject().field("text", "lucene release").endObject())).actionGet();
    client().admin().indices().refresh(refreshRequest()).actionGet();

    logger.info("Running moreLikeThis");
    SearchResponse response = client().prepareSearch().setQuery(
            new MoreLikeThisQueryBuilder(null, new Item[] {new Item("test", "type1", "1")}).minTermFreq(1).minDocFreq(1)).get();
    assertHitCount(response, 1L);
}

public void testSimpleMoreLikeOnLongField() throws Exception {
    logger.info("Creating index test");
    assertAcked(prepareCreate("test").addMapping("type1", "some_long", "type=long"));
    logger.info("Running Cluster Health");
    assertThat(ensureGreen(), equalTo(ClusterHealthStatus.GREEN));

    logger.info("Indexing...");
    client().index(indexRequest("test").type("type1").id("1").source(jsonBuilder().startObject().field("some_long", 1367484649580L).endObject())).actionGet();
    client().index(indexRequest("test").type("type2").id("2").source(jsonBuilder().startObject().field("some_long", 0).endObject())).actionGet();
    client().index(indexRequest("test").type("type1").id("3").source(jsonBuilder().startObject().field("some_long", -666).endObject())).actionGet();

    client().admin().indices().refresh(refreshRequest()).actionGet();

    logger.info("Running moreLikeThis");
    SearchResponse response = client().prepareSearch().setQuery(
            new MoreLikeThisQueryBuilder(null, new Item[] {new Item("test", "type1", "1")}).minTermFreq(1).minDocFreq(1)).get();
    assertHitCount(response, 0L);
}

public void testMoreLikeThisWithAliasesInLikeDocuments() throws Exception {
    String indexName = "foo";
    String aliasName = "foo_name";
    String typeName = "bar";

    String mapping = XContentFactory.jsonBuilder().startObject().startObject("bar")
            .startObject("properties")
            .endObject()
            .endObject().endObject().string();
    client().admin().indices().prepareCreate(indexName).addMapping(typeName, mapping, XContentType.JSON).get();
    client().admin().indices().prepareAliases().addAlias(indexName, aliasName).get();

    assertThat(ensureGreen(), equalTo(ClusterHealthStatus.GREEN));

    client().index(indexRequest(indexName).type(typeName).id("1").source(jsonBuilder().startObject().field("text", "elasticsearch index").endObject())).actionGet();
    client().index(indexRequest(indexName).type(typeName).id("2").source(jsonBuilder().startObject().field("text", "lucene index").endObject())).actionGet();
    client().index(indexRequest(indexName).type(typeName).id("3").source(jsonBuilder().startObject().field("text", "elasticsearch index").endObject())).actionGet();
    refresh(indexName);

    SearchResponse response = client().prepareSearch().setQuery(
            new MoreLikeThisQueryBuilder(null, new Item[] {new Item(aliasName, typeName, "1")}).minTermFreq(1).minDocFreq(1)).get();
    assertHitCount(response, 2L);
    assertThat(response.getHits().getAt(0).getId(), equalTo("3"));
}

public void testMoreLikeThisIssue2197() throws Exception {
    Client client = client();
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("bar")
            .startObject("properties")
            .endObject()
            .endObject().endObject().string();
    client().admin().indices().prepareCreate("foo").addMapping("bar", mapping, XContentType.JSON).execute().actionGet();
    client().prepareIndex("foo", "bar", "1")
            .setSource(jsonBuilder().startObject().startObject("foo").field("bar", "boz").endObject().endObject())
            .execute().actionGet();
    client().admin().indices().prepareRefresh("foo").execute().actionGet();
    assertThat(ensureGreen(), equalTo(ClusterHealthStatus.GREEN));

    SearchResponse response = client().prepareSearch().setQuery(
            new MoreLikeThisQueryBuilder(null, new Item[] {new Item("foo", "bar", "1")})).get();
    assertNoFailures(response);
    assertThat(response, notNullValue());
    response = client().prepareSearch().setQuery(
            new MoreLikeThisQueryBuilder(null, new Item[] {new Item("foo", "bar", "1")})).get();
    assertNoFailures(response);
    assertThat(response, notNullValue());
}

public void testMoreLikeWithCustomRouting() throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("bar")
            .startObject("properties")
            .endObject()
            .endObject().endObject().string();
    client().admin().indices().prepareCreate("foo").addMapping("bar", mapping, XContentType.JSON).execute().actionGet();
    ensureGreen();

    client().prepareIndex("foo", "bar", "1")
            .setSource(jsonBuilder().startObject().startObject("foo").field("bar", "boz").endObject().endObject())
            .setRouting("2")
            .execute().actionGet();
    client().admin().indices().prepareRefresh("foo").execute().actionGet();

    SearchResponse response = client().prepareSearch().setQuery(
            new MoreLikeThisQueryBuilder(null, new Item[] {new Item("foo", "bar", "1").routing("2")})).get();
    assertNoFailures(response);
    assertThat(response, notNullValue());
}

public void testMoreLikeThisIssueRoutingNotSerialized() throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("bar")
            .startObject("properties")
            .endObject()
            .endObject().endObject().string();
    assertAcked(prepareCreate("foo", 2,
            Settings.builder().put(SETTING_NUMBER_OF_SHARDS, 2).put(SETTING_NUMBER_OF_REPLICAS, 0))
            .addMapping("bar", mapping, XContentType.JSON));
    ensureGreen();

    client().prepareIndex("foo", "bar", "1")
            .setSource(jsonBuilder().startObject().startObject("foo").field("bar", "boz").endObject().endObject())
            .setRouting("4000")
            .execute().actionGet();
    client().admin().indices().prepareRefresh("foo").execute().actionGet();
    SearchResponse response = client().prepareSearch().setQuery(
            new MoreLikeThisQueryBuilder(null, new Item[] {new Item("foo", "bar", "1").routing("4000")})).get();
    assertNoFailures(response);
    assertThat(response, notNullValue());
}

public void testSimpleMoreLikeThisIds() throws Exception {
    logger.info("Creating index test");
    assertAcked(prepareCreate("test").addMapping("type1",
            jsonBuilder().startObject().startObject("type1").startObject("properties")
                    .startObject("text").field("type", "text").endObject()
                    .endObject().endObject().endObject()));

    logger.info("Running Cluster Health");
    assertThat(ensureGreen(), equalTo(ClusterHealthStatus.GREEN));

    logger.info("Indexing...");
    List<IndexRequestBuilder> builders = new ArrayList<>();
    builders.add(client().prepareIndex("test", "type1").setSource("text", "lucene").setId("1"));
    builders.add(client().prepareIndex("test", "type1").setSource("text", "lucene release").setId("2"));
    builders.add(client().prepareIndex("test", "type1").setSource("text", "apache lucene").setId("3"));
    indexRandom(true, builders);

    logger.info("Running MoreLikeThis");
    MoreLikeThisQueryBuilder queryBuilder = QueryBuilders.moreLikeThisQuery(new String[] {"text"}, null, ids("1")).include(true).minTermFreq(1).minDocFreq(1);
    SearchResponse mltResponse = client().prepareSearch().setTypes("type1").setQuery(queryBuilder).execute().actionGet();
    assertHitCount(mltResponse, 3L);
}

public void testMoreLikeThisArtificialDocs() throws Exception {
    int numFields = randomIntBetween(5, 10);

    createIndex("test");
    ensureGreen();

    logger.info("Indexing a single document ...");
    XContentBuilder doc = jsonBuilder().startObject();
    for (int i = 0; i < numFields; i++) {
        doc.field("field" + i, generateRandomStringArray(5, 10, false) + "a"); // make sure they are not all empty
    }
    doc.endObject();
    indexRandom(true, client().prepareIndex("test", "type1", "0").setSource(doc));

    logger.info("Checking the document matches ...");
    MoreLikeThisQueryBuilder mltQuery = moreLikeThisQuery(new Item[] {new Item("test", "type1", doc).routing("0")})  // routing to ensure we hit the shard with the doc
            .minTermFreq(0)
            .minDocFreq(0)
            .maxQueryTerms(100)
            .minimumShouldMatch("100%"); // strict all terms must match!
    SearchResponse response = client().prepareSearch("test").setTypes("type1")
            .setQuery(mltQuery).get();
    assertSearchResponse(response);
    assertHitCount(response, 1);
}

@Test
public void testSimpleMoreLikeThisIds() throws Exception {
    logger.info("Creating index test");
    assertAcked(prepareCreate("test").addMapping("type1",
            jsonBuilder().startObject().startObject("type1").startObject("properties")
                    .startObject("text").field("type", "string").endObject()
                    .endObject().endObject().endObject()));

    logger.info("Running Cluster Health");
    assertThat(ensureGreen(), equalTo(ClusterHealthStatus.GREEN));

    logger.info("Indexing...");
    List<IndexRequestBuilder> builders = new ArrayList<>();
    builders.add(client().prepareIndex("test", "type1").setSource("text", "lucene").setId("1"));
    builders.add(client().prepareIndex("test", "type1").setSource("text", "lucene release").setId("2"));
    builders.add(client().prepareIndex("test", "type1").setSource("text", "apache lucene").setId("3"));
    indexRandom(true, builders);

    logger.info("Running MoreLikeThis");
    MoreLikeThisQueryBuilder queryBuilder = QueryBuilders.moreLikeThisQuery("text").ids("1").include(true).minTermFreq(1).minDocFreq(1);
    SearchResponse mltResponse = httpClient.search(Requests.searchRequest("test").types("type1").source(new SearchSourceBuilder().query(queryBuilder))).get();
    assertHitCount(mltResponse, 3l);
}

public void testSimpleMoreLikeInclude() throws Exception {
    logger.info("Creating index test");
    assertAcked(prepareCreate("test").addMapping("type1",
            jsonBuilder().startObject().startObject("type1").startObject("properties")
                    .startObject("text").field("type", "text").endObject()
                    .endObject().endObject().endObject()));

    logger.info("Running Cluster Health");
    assertThat(ensureGreen(), equalTo(ClusterHealthStatus.GREEN));

    logger.info("Indexing...");
    client().index(indexRequest("test").type("type1").id("1").source(
            jsonBuilder().startObject()
                    .field("text", "Apache Lucene is a free/open source information retrieval software library").endObject()))
            .actionGet();
    client().index(indexRequest("test").type("type1").id("2").source(
            jsonBuilder().startObject()
                    .field("text", "Lucene has been ported to other programming languages").endObject()))
            .actionGet();
    client().admin().indices().refresh(refreshRequest()).actionGet();

    logger.info("Running More Like This with include true");
    SearchResponse response = client().prepareSearch().setQuery(
            new MoreLikeThisQueryBuilder(null, new Item[] {new Item("test", "type1", "1")}).minTermFreq(1).minDocFreq(1).include(true).minimumShouldMatch("0%")).get();
    assertOrderedSearchHits(response, "1", "2");

    response = client().prepareSearch().setQuery(
            new MoreLikeThisQueryBuilder(null, new Item[] {new Item("test", "type1", "2")}).minTermFreq(1).minDocFreq(1).include(true).minimumShouldMatch("0%")).get();
    assertOrderedSearchHits(response, "2", "1");

    logger.info("Running More Like This with include false");
    response = client().prepareSearch().setQuery(
            new MoreLikeThisQueryBuilder(null, new Item[] {new Item("test", "type1", "1")}).minTermFreq(1).minDocFreq(1).minimumShouldMatch("0%")).get();
    assertSearchHits(response, "2");
}

public void testSimpleMoreLikeThisIdsMultipleTypes() throws Exception {
    logger.info("Creating index test");
    int numOfTypes = randomIntBetween(2, 10);
    CreateIndexRequestBuilder createRequestBuilder = prepareCreate("test");
    for (int i = 0; i < numOfTypes; i++) {
        createRequestBuilder.addMapping("type" + i, jsonBuilder().startObject().startObject("type" + i).startObject("properties")
                .startObject("text").field("type", "text").endObject()
                .endObject().endObject().endObject());
    }
    assertAcked(createRequestBuilder);

    logger.info("Running Cluster Health");
    assertThat(ensureGreen(), equalTo(ClusterHealthStatus.GREEN));

    logger.info("Indexing...");
    List<IndexRequestBuilder> builders = new ArrayList<>(numOfTypes);
    for (int i = 0; i < numOfTypes; i++) {
        builders.add(client().prepareIndex("test", "type" + i).setSource("text", "lucene" + " " + i).setId(String.valueOf(i)));
    }
    indexRandom(true, builders);

    logger.info("Running MoreLikeThis");
    MoreLikeThisQueryBuilder queryBuilder = QueryBuilders.moreLikeThisQuery(new String[] {"text"}, null, new Item[] {new Item("test", "type0", "0")}).include(true).minTermFreq(1).minDocFreq(1);

    String[] types = new String[numOfTypes];
    for (int i = 0; i < numOfTypes; i++) {
        types[i] = "type"+i;
    }
    SearchResponse mltResponse = client().prepareSearch().setTypes(types).setQuery(queryBuilder).execute().actionGet();
    assertHitCount(mltResponse, numOfTypes);
}

public void testMoreLikeThisMultiValueFields() throws Exception {
    logger.info("Creating the index ...");
    assertAcked(prepareCreate("test")
            .addMapping("type1", "text", "type=text,analyzer=keyword")
            .setSettings(SETTING_NUMBER_OF_SHARDS, 1));
    ensureGreen();

    logger.info("Indexing ...");
    String[] values = {"aaaa", "bbbb", "cccc", "dddd", "eeee", "ffff", "gggg", "hhhh", "iiii", "jjjj"};
    List<IndexRequestBuilder> builders = new ArrayList<>(values.length + 1);
    // index one document with all the values
    builders.add(client().prepareIndex("test", "type1", "0").setSource("text", values));
    // index each document with only one of the values
    for (int i = 0; i < values.length; i++) {
        builders.add(client().prepareIndex("test", "type1", String.valueOf(i + 1)).setSource("text", values[i]));
    }
    indexRandom(true, builders);

    int maxIters = randomIntBetween(10, 20);
    for (int i = 0; i < maxIters; i++) {
        int max_query_terms = randomIntBetween(1, values.length);
        logger.info("Running More Like This with max_query_terms = {}", max_query_terms);
        MoreLikeThisQueryBuilder mltQuery = moreLikeThisQuery(new String[] {"text"}, null, new Item[] {new Item(null, null, "0")})
                .minTermFreq(1).minDocFreq(1)
                .maxQueryTerms(max_query_terms).minimumShouldMatch("0%");
        SearchResponse response = client().prepareSearch("test").setTypes("type1")
                .setQuery(mltQuery).execute().actionGet();
        assertSearchResponse(response);
        assertHitCount(response, max_query_terms);
    }
}

public void testMinimumShouldMatch() throws ExecutionException, InterruptedException {
    logger.info("Creating the index ...");
    assertAcked(prepareCreate("test")
            .addMapping("type1", "text", "type=text,analyzer=whitespace")
            .setSettings(SETTING_NUMBER_OF_SHARDS, 1));
    ensureGreen();

    logger.info("Indexing with each doc having one less term ...");
    List<IndexRequestBuilder> builders = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        String text = "";
        for (int j = 1; j <= 10 - i; j++) {
            text += j + " ";
        }
        builders.add(client().prepareIndex("test", "type1", i + "").setSource("text", text));
    }
    indexRandom(true, builders);

    logger.info("Testing each minimum_should_match from 0% - 100% with 10% increment ...");
    for (int i = 0; i <= 10; i++) {
        String minimumShouldMatch = (10 * i) + "%";
        MoreLikeThisQueryBuilder mltQuery = moreLikeThisQuery(new String[] {"text"}, new String[] {"1 2 3 4 5 6 7 8 9 10"}, null)
                .minTermFreq(1)
                .minDocFreq(1)
                .minimumShouldMatch(minimumShouldMatch);
        logger.info("Testing with minimum_should_match = {}", minimumShouldMatch);
        SearchResponse response = client().prepareSearch("test").setTypes("type1")
                .setQuery(mltQuery).get();
        assertSearchResponse(response);
        if (minimumShouldMatch.equals("0%")) {
            assertHitCount(response, 10);
        } else {
            assertHitCount(response, 11 - i);
        }
    }
}

public void testSelectFields() throws IOException, ExecutionException, InterruptedException {
    assertAcked(prepareCreate("test")
            .addMapping("type1", "text", "type=text,analyzer=whitespace", "text1", "type=text,analyzer=whitespace"));
    ensureGreen("test");

    indexRandom(true, client().prepareIndex("test", "type1", "1").setSource(jsonBuilder()
                    .startObject()
                    .field("text", "hello world")
                    .field("text1", "elasticsearch")
                    .endObject()),
            client().prepareIndex("test", "type1", "2").setSource(jsonBuilder()
                    .startObject()
                    .field("text", "goodby moon")
                    .field("text1", "elasticsearch")
                    .endObject()));

    MoreLikeThisQueryBuilder mltQuery = moreLikeThisQuery(new Item[] {new Item("test", "type1", "1")})
            .minTermFreq(0)
            .minDocFreq(0)
            .include(true)
            .minimumShouldMatch("1%");
    SearchResponse response = client().prepareSearch("test").setTypes("type1")
            .setQuery(mltQuery).get();
    assertSearchResponse(response);
    assertHitCount(response, 2);

    mltQuery = moreLikeThisQuery(new String[] {"text"}, null, new Item[] {new Item("test", "type1", "1")})
            .minTermFreq(0)
            .minDocFreq(0)
            .include(true)
            .minimumShouldMatch("1%");
    response = client().prepareSearch("test").setTypes("type1")
            .setQuery(mltQuery).get();
    assertSearchResponse(response);
    assertHitCount(response, 1);
}

/**
 * 根据网页ID获取相似页面
 * @param id
 * @param page
 * @param size
 * @return
 */
public List<Webpage> moreLikeThis(String id, int page, int size) {
    MoreLikeThisQueryBuilder.Item[] items = {new MoreLikeThisQueryBuilder.Item(INDEX_NAME, TYPE_NAME, id)};
    String[] fields = {"content"};
    SearchResponse response = search().setSize(size).setFrom(size*(page-1))
            .setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
            .setQuery(QueryBuilders.moreLikeThisQuery(fields, null, items)
                    .minTermFreq(1).maxQueryTerms(12)).get();
    return hitsToList(response.getHits());
}

@Override
public <T> Page<T> moreLikeThis(MoreLikeThisQuery query, Class<T> clazz) {
    ElasticsearchPersistentEntity persistentEntity = getPersistentEntityFor(clazz);
    String indexName = isNotBlank(query.getIndexName()) ? query.getIndexName() : persistentEntity.getIndexName();
    String type = isNotBlank(query.getType()) ? query.getType() : persistentEntity.getIndexType();

    Assert.notNull(indexName, "No 'indexName' defined for MoreLikeThisQuery");
    Assert.notNull(type, "No 'type' defined for MoreLikeThisQuery");
    Assert.notNull(query.getId(), "No document id defined for MoreLikeThisQuery");

    MoreLikeThisQueryBuilder moreLikeThisQueryBuilder = moreLikeThisQuery(toArray(new MoreLikeThisQueryBuilder.Item(indexName, type, query.getId())));

    if (query.getMinTermFreq() != null) {
        moreLikeThisQueryBuilder.minTermFreq(query.getMinTermFreq());
    }
    if (query.getMaxQueryTerms() != null) {
        moreLikeThisQueryBuilder.maxQueryTerms(query.getMaxQueryTerms());
    }
    if (!isEmpty(query.getStopWords())) {
        moreLikeThisQueryBuilder.stopWords(toArray(query.getStopWords()));
    }
    if (query.getMinDocFreq() != null) {
        moreLikeThisQueryBuilder.minDocFreq(query.getMinDocFreq());
    }
    if (query.getMaxDocFreq() != null) {
        moreLikeThisQueryBuilder.maxDocFreq(query.getMaxDocFreq());
    }
    if (query.getMinWordLen() != null) {
        moreLikeThisQueryBuilder.minWordLength(query.getMinWordLen());
    }
    if (query.getMaxWordLen() != null) {
        moreLikeThisQueryBuilder.maxWordLength(query.getMaxWordLen());
    }
    if (query.getBoostTerms() != null) {
        moreLikeThisQueryBuilder.boostTerms(query.getBoostTerms());
    }

    return queryForPage(new NativeSearchQueryBuilder().withQuery(moreLikeThisQueryBuilder).build(), clazz);
}

public MoreLikeThisQueryBuilder.Item buildMLTItem(String id) {
    return new MoreLikeThisQueryBuilder.Item(getIndexName(), getIndexType(), id);
}

private void registerQueryParsers(List<SearchPlugin> plugins) {
    registerQuery(new QuerySpec<>(MatchQueryBuilder.NAME, MatchQueryBuilder::new, MatchQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(MatchPhraseQueryBuilder.NAME, MatchPhraseQueryBuilder::new, MatchPhraseQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(MatchPhrasePrefixQueryBuilder.NAME, MatchPhrasePrefixQueryBuilder::new,
            MatchPhrasePrefixQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(MultiMatchQueryBuilder.NAME, MultiMatchQueryBuilder::new, MultiMatchQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(NestedQueryBuilder.NAME, NestedQueryBuilder::new, NestedQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(HasChildQueryBuilder.NAME, HasChildQueryBuilder::new, HasChildQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(HasParentQueryBuilder.NAME, HasParentQueryBuilder::new, HasParentQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(DisMaxQueryBuilder.NAME, DisMaxQueryBuilder::new, DisMaxQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(IdsQueryBuilder.NAME, IdsQueryBuilder::new, IdsQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(MatchAllQueryBuilder.NAME, MatchAllQueryBuilder::new, MatchAllQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(QueryStringQueryBuilder.NAME, QueryStringQueryBuilder::new, QueryStringQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(BoostingQueryBuilder.NAME, BoostingQueryBuilder::new, BoostingQueryBuilder::fromXContent));
    BooleanQuery.setMaxClauseCount(INDICES_MAX_CLAUSE_COUNT_SETTING.get(settings));
    registerQuery(new QuerySpec<>(BoolQueryBuilder.NAME, BoolQueryBuilder::new, BoolQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(TermQueryBuilder.NAME, TermQueryBuilder::new, TermQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(TermsQueryBuilder.NAME, TermsQueryBuilder::new, TermsQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(FuzzyQueryBuilder.NAME, FuzzyQueryBuilder::new, FuzzyQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(RegexpQueryBuilder.NAME, RegexpQueryBuilder::new, RegexpQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(RangeQueryBuilder.NAME, RangeQueryBuilder::new, RangeQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(PrefixQueryBuilder.NAME, PrefixQueryBuilder::new, PrefixQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(WildcardQueryBuilder.NAME, WildcardQueryBuilder::new, WildcardQueryBuilder::fromXContent));
    registerQuery(
            new QuerySpec<>(ConstantScoreQueryBuilder.NAME, ConstantScoreQueryBuilder::new, ConstantScoreQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanTermQueryBuilder.NAME, SpanTermQueryBuilder::new, SpanTermQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanNotQueryBuilder.NAME, SpanNotQueryBuilder::new, SpanNotQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanWithinQueryBuilder.NAME, SpanWithinQueryBuilder::new, SpanWithinQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanContainingQueryBuilder.NAME, SpanContainingQueryBuilder::new,
            SpanContainingQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(FieldMaskingSpanQueryBuilder.NAME, FieldMaskingSpanQueryBuilder::new,
            FieldMaskingSpanQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanFirstQueryBuilder.NAME, SpanFirstQueryBuilder::new, SpanFirstQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanNearQueryBuilder.NAME, SpanNearQueryBuilder::new, SpanNearQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(SpanOrQueryBuilder.NAME, SpanOrQueryBuilder::new, SpanOrQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(MoreLikeThisQueryBuilder.NAME, MoreLikeThisQueryBuilder::new,
            MoreLikeThisQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(WrapperQueryBuilder.NAME, WrapperQueryBuilder::new, WrapperQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(CommonTermsQueryBuilder.NAME, CommonTermsQueryBuilder::new, CommonTermsQueryBuilder::fromXContent));
    registerQuery(
            new QuerySpec<>(SpanMultiTermQueryBuilder.NAME, SpanMultiTermQueryBuilder::new, SpanMultiTermQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(FunctionScoreQueryBuilder.NAME, FunctionScoreQueryBuilder::new,
            FunctionScoreQueryBuilder::fromXContent));
    registerQuery(
            new QuerySpec<>(SimpleQueryStringBuilder.NAME, SimpleQueryStringBuilder::new, SimpleQueryStringBuilder::fromXContent));
    registerQuery(new QuerySpec<>(TypeQueryBuilder.NAME, TypeQueryBuilder::new, TypeQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(ScriptQueryBuilder.NAME, ScriptQueryBuilder::new, ScriptQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(GeoDistanceQueryBuilder.NAME, GeoDistanceQueryBuilder::new, GeoDistanceQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(GeoBoundingBoxQueryBuilder.NAME, GeoBoundingBoxQueryBuilder::new,
            GeoBoundingBoxQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(GeoPolygonQueryBuilder.NAME, GeoPolygonQueryBuilder::new, GeoPolygonQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(ExistsQueryBuilder.NAME, ExistsQueryBuilder::new, ExistsQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(MatchNoneQueryBuilder.NAME, MatchNoneQueryBuilder::new, MatchNoneQueryBuilder::fromXContent));
    registerQuery(new QuerySpec<>(ParentIdQueryBuilder.NAME, ParentIdQueryBuilder::new, ParentIdQueryBuilder::fromXContent));

    if (ShapesAvailability.JTS_AVAILABLE && ShapesAvailability.SPATIAL4J_AVAILABLE) {
        registerQuery(new QuerySpec<>(GeoShapeQueryBuilder.NAME, GeoShapeQueryBuilder::new, GeoShapeQueryBuilder::fromXContent));
    }

    registerFromPlugin(plugins, SearchPlugin::getQueries, this::registerQuery);
}

public void testMoreLikeThisWithAliases() throws Exception {
    logger.info("Creating index test");
    assertAcked(prepareCreate("test").addMapping("type1",
            jsonBuilder().startObject().startObject("type1").startObject("properties")
                    .startObject("text").field("type", "text").endObject()
                    .endObject().endObject().endObject()));
    logger.info("Creating aliases alias release");
    client().admin().indices().prepareAliases()
        .addAlias("test", "release", termQuery("text", "release"))
        .addAlias("test", "beta", termQuery("text", "beta")).get();

    logger.info("Running Cluster Health");
    assertThat(ensureGreen(), equalTo(ClusterHealthStatus.GREEN));

    logger.info("Indexing...");
    client().index(indexRequest("test").type("type1").id("1").source(jsonBuilder().startObject().field("text", "lucene beta").endObject())).actionGet();
    client().index(indexRequest("test").type("type1").id("2").source(jsonBuilder().startObject().field("text", "lucene release").endObject())).actionGet();
    client().index(indexRequest("test").type("type1").id("3").source(jsonBuilder().startObject().field("text", "elasticsearch beta").endObject())).actionGet();
    client().index(indexRequest("test").type("type1").id("4").source(jsonBuilder().startObject().field("text", "elasticsearch release").endObject())).actionGet();
    client().admin().indices().refresh(refreshRequest()).actionGet();

    logger.info("Running moreLikeThis on index");
    SearchResponse response = client().prepareSearch().setQuery(
            new MoreLikeThisQueryBuilder(null, new Item[] {new Item("test", "type1", "1")}).minTermFreq(1).minDocFreq(1)).get();
    assertHitCount(response, 2L);

    logger.info("Running moreLikeThis on beta shard");
    response = client().prepareSearch("beta").setQuery(
            new MoreLikeThisQueryBuilder(null, new Item[] {new Item("test", "type1", "1")}).minTermFreq(1).minDocFreq(1)).get();
    assertHitCount(response, 1L);
    assertThat(response.getHits().getAt(0).getId(), equalTo("3"));

    logger.info("Running moreLikeThis on release shard");
    response = client().prepareSearch("release").setQuery(
            new MoreLikeThisQueryBuilder(null, new Item[] {new Item("test", "type1", "1")}).minTermFreq(1).minDocFreq(1)).get();
    assertHitCount(response, 1L);
    assertThat(response.getHits().getAt(0).getId(), equalTo("2"));

    logger.info("Running moreLikeThis on alias with node client");
    response = internalCluster().coordOnlyNodeClient().prepareSearch("beta").setQuery(
            new MoreLikeThisQueryBuilder(null, new Item[] {new Item("test", "type1", "1")}).minTermFreq(1).minDocFreq(1)).get();
    assertHitCount(response, 1L);
    assertThat(response.getHits().getAt(0).getId(), equalTo("3"));
}

public void testNumericField() throws Exception {
    final String[] numericTypes = new String[]{"byte", "short", "integer", "long"};
    prepareCreate("test").addMapping("type", jsonBuilder()
                .startObject().startObject("type")
                .startObject("properties")
                    .startObject("int_value").field("type", randomFrom(numericTypes)).endObject()
                    .startObject("string_value").field("type", "text").endObject()
                    .endObject()
                .endObject().endObject()).execute().actionGet();
    ensureGreen();
    client().prepareIndex("test", "type", "1")
            .setSource(jsonBuilder().startObject().field("string_value", "lucene index").field("int_value", 1).endObject())
            .execute().actionGet();
    client().prepareIndex("test", "type", "2")
            .setSource(jsonBuilder().startObject().field("string_value", "elasticsearch index").field("int_value", 42).endObject())
            .execute().actionGet();

    refresh();

    // Implicit list of fields -> ignore numeric fields
    SearchResponse searchResponse = client().prepareSearch().setQuery(
            new MoreLikeThisQueryBuilder(null, new Item[] {new Item("test", "type", "1")}).minTermFreq(1).minDocFreq(1)).get();
    assertHitCount(searchResponse, 1L);

    // Explicit list of fields including numeric fields -> fail
    assertThrows(client().prepareSearch().setQuery(
            new MoreLikeThisQueryBuilder(new String[] {"string_value", "int_value"}, null, new Item[] {new Item("test", "type", "1")}).minTermFreq(1).minDocFreq(1)), SearchPhaseExecutionException.class);

    // mlt query with no field -> No results (because _all is not enabled)
    searchResponse = client().prepareSearch().setQuery(moreLikeThisQuery(new String[] {"index"}).minTermFreq(1).minDocFreq(1)).execute().actionGet();
    assertHitCount(searchResponse, 0L);

    // mlt query with string fields
    searchResponse = client().prepareSearch().setQuery(moreLikeThisQuery(new String[]{"string_value"}, new String[] {"index"}, null).minTermFreq(1).minDocFreq(1)).execute().actionGet();
    assertHitCount(searchResponse, 2L);

    // mlt query with at least a numeric field -> fail by default
    assertThrows(client().prepareSearch().setQuery(moreLikeThisQuery(new String[] {"string_value", "int_value"}, new String[] {"index"}, null)), SearchPhaseExecutionException.class);

    // mlt query with at least a numeric field -> fail by command
    assertThrows(client().prepareSearch().setQuery(moreLikeThisQuery(new String[] {"string_value", "int_value"}, new String[] {"index"}, null).failOnUnsupportedField(true)), SearchPhaseExecutionException.class);


    // mlt query with at least a numeric field but fail_on_unsupported_field set to false
    searchResponse = client().prepareSearch().setQuery(moreLikeThisQuery(new String[] {"string_value", "int_value"}, new String[] {"index"}, null).minTermFreq(1).minDocFreq(1).failOnUnsupportedField(false)).get();
    assertHitCount(searchResponse, 2L);

    // mlt field query on a numeric field -> failure by default
    assertThrows(client().prepareSearch().setQuery(moreLikeThisQuery(new String[] {"int_value"}, new String[] {"42"}, null).minTermFreq(1).minDocFreq(1)), SearchPhaseExecutionException.class);

    // mlt field query on a numeric field -> failure by command
    assertThrows(client().prepareSearch().setQuery(moreLikeThisQuery(new String[] {"int_value"}, new String[] {"42"}, null).minTermFreq(1).minDocFreq(1).failOnUnsupportedField(true)),
            SearchPhaseExecutionException.class);

    // mlt field query on a numeric field but fail_on_unsupported_field set to false
    searchResponse = client().prepareSearch().setQuery(moreLikeThisQuery(new String[] {"int_value"}, new String[] {"42"}, null).minTermFreq(1).minDocFreq(1).failOnUnsupportedField(false)).execute().actionGet();
    assertHitCount(searchResponse, 0L);
}

public void testMoreLikeThisMalformedArtificialDocs() throws Exception {
    logger.info("Creating the index ...");
    assertAcked(prepareCreate("test")
            .addMapping("type1", "text", "type=text,analyzer=whitespace", "date", "type=date"));
    ensureGreen("test");

    logger.info("Creating an index with a single document ...");
    indexRandom(true, client().prepareIndex("test", "type1", "1").setSource(jsonBuilder()
            .startObject()
            .field("text", "Hello World!")
            .field("date", "2009-01-01")
            .endObject()));

    logger.info("Checking with a malformed field value ...");
    XContentBuilder malformedFieldDoc = jsonBuilder()
            .startObject()
            .field("text", "Hello World!")
            .field("date", "this is not a date!")
            .endObject();
    MoreLikeThisQueryBuilder mltQuery = moreLikeThisQuery(new Item[] {new Item("test", "type1", malformedFieldDoc)})
            .minTermFreq(0)
            .minDocFreq(0)
            .minimumShouldMatch("0%");
    SearchResponse response = client().prepareSearch("test").setTypes("type1")
            .setQuery(mltQuery).get();
    assertSearchResponse(response);
    assertHitCount(response, 0);

    logger.info("Checking with an empty document ...");
    XContentBuilder emptyDoc = jsonBuilder().startObject().endObject();
    mltQuery = moreLikeThisQuery(null, new Item[] {new Item("test", "type1", emptyDoc)})
            .minTermFreq(0)
            .minDocFreq(0)
            .minimumShouldMatch("0%");
    response = client().prepareSearch("test").setTypes("type1")
            .setQuery(mltQuery).get();
    assertSearchResponse(response);
    assertHitCount(response, 0);

    logger.info("Checking the document matches otherwise ...");
    XContentBuilder normalDoc = jsonBuilder()
            .startObject()
            .field("text", "Hello World!")
            .field("date", "1000-01-01") // should be properly parsed but ignored ...
            .endObject();
    mltQuery = moreLikeThisQuery(null, new Item[] {new Item("test", "type1", normalDoc)})
            .minTermFreq(0)
            .minDocFreq(0)
            .minimumShouldMatch("100%");  // strict all terms must match but date is ignored
    response = client().prepareSearch("test").setTypes("type1")
            .setQuery(mltQuery).get();
    assertSearchResponse(response);
    assertHitCount(response, 1);
}

public void testMoreLikeThisUnlike() throws ExecutionException, InterruptedException, IOException {
    createIndex("test");
    ensureGreen();
    int numFields = randomIntBetween(5, 10);

    logger.info("Create a document that has all the fields.");
    XContentBuilder doc = jsonBuilder().startObject();
    for (int i = 0; i < numFields; i++) {
        doc.field("field"+i, i+"");
    }
    doc.endObject();

    logger.info("Indexing each field value of this document as a single document.");
    List<IndexRequestBuilder> builders = new ArrayList<>();
    for (int i = 0; i < numFields; i++) {
        builders.add(client().prepareIndex("test", "type1", i+"").setSource("field"+i, i+""));
    }
    indexRandom(true, builders);

    logger.info("First check the document matches all indexed docs.");
    MoreLikeThisQueryBuilder mltQuery = moreLikeThisQuery(new Item[] {new Item("test", "type1", doc)})
            .minTermFreq(0)
            .minDocFreq(0)
            .maxQueryTerms(100)
            .minimumShouldMatch("0%");
    SearchResponse response = client().prepareSearch("test").setTypes("type1")
            .setQuery(mltQuery).get();
    assertSearchResponse(response);
    assertHitCount(response, numFields);

    logger.info("Now check like this doc, but ignore one doc in the index, then two and so on...");
    List<Item> docs = new ArrayList<>(numFields);
    for (int i = 0; i < numFields; i++) {
        docs.add(new Item("test", "type1", i+""));
        mltQuery = moreLikeThisQuery(null, new Item[] {new Item("test", "type1", doc)})
                .unlike(docs.toArray(new Item[docs.size()]))
                .minTermFreq(0)
                .minDocFreq(0)
                .maxQueryTerms(100)
                .include(true)
                .minimumShouldMatch("0%");

        response = client().prepareSearch("test").setTypes("type1").setQuery(mltQuery).get();
        assertSearchResponse(response);
        assertHitCount(response, numFields - (i + 1));
    }
}

public void testExplainWithRewriteValidateQuery() throws Exception {
    client().admin().indices().prepareCreate("test")
            .addMapping("type1", "field", "type=text,analyzer=whitespace")
            .setSettings(SETTING_NUMBER_OF_SHARDS, 1).get();
    client().prepareIndex("test", "type1", "1").setSource("field", "quick lazy huge brown pidgin").get();
    client().prepareIndex("test", "type1", "2").setSource("field", "the quick brown fox").get();
    client().prepareIndex("test", "type1", "3").setSource("field", "the quick lazy huge brown fox jumps over the tree").get();
    client().prepareIndex("test", "type1", "4").setSource("field", "the lazy dog quacks like a duck").get();
    refresh();

    // prefix queries
    assertExplanation(QueryBuilders.matchPhrasePrefixQuery("field", "qu"),
            containsString("field:quick"), true);
    assertExplanation(QueryBuilders.matchPhrasePrefixQuery("field", "ju"),
            containsString("field:jumps"), true);

    // common terms queries
    assertExplanation(QueryBuilders.commonTermsQuery("field", "huge brown pidgin").cutoffFrequency(1),
            containsString("+field:pidgin (field:huge field:brown)"), true);
    assertExplanation(QueryBuilders.commonTermsQuery("field", "the brown").analyzer("stop"),
            containsString("field:brown"), true);

    // match queries with cutoff frequency
    assertExplanation(QueryBuilders.matchQuery("field", "huge brown pidgin").cutoffFrequency(1),
            containsString("+field:pidgin (field:huge field:brown)"), true);
    assertExplanation(QueryBuilders.matchQuery("field", "the brown").analyzer("stop"),
            containsString("field:brown"), true);

    // fuzzy queries
    assertExplanation(QueryBuilders.fuzzyQuery("field", "the").fuzziness(Fuzziness.fromEdits(2)),
            containsString("field:the (field:tree)^0.3333333"), true);
    assertExplanation(QueryBuilders.fuzzyQuery("field", "jump"),
            containsString("(field:jumps)^0.75"), true);

    // more like this queries
    assertExplanation(QueryBuilders.moreLikeThisQuery(new String[] { "field" }, null, MoreLikeThisQueryBuilder.ids("1"))
                    .include(true).minTermFreq(1).minDocFreq(1).maxQueryTerms(2),
            containsString("field:huge field:pidgin"), true);
    assertExplanation(QueryBuilders.moreLikeThisQuery(new String[] { "field" }, new String[] {"the huge pidgin"}, null)
                    .minTermFreq(1).minDocFreq(1).maxQueryTerms(2),
            containsString("field:huge field:pidgin"), true);
}

private static MoreLikeThisQueryBuilder.Item[] toArray(MoreLikeThisQueryBuilder.Item... values) {
    return values;
}