Java QueryBuilders.matchQuery方法代码示例

import org.elasticsearch.index.query.QueryBuilders; //导入方法依赖的package包/类
/**
 * Here to establish QueryBuilder patterns
 */
void test() {
	SearchSourceBuilder b;
	BoolQueryBuilder qb = QueryBuilders.boolQuery();
	QueryBuilder qbmm = QueryBuilders.multiMatchQuery("name", "fieldNames");
	QueryBuilder qbm = QueryBuilders.matchQuery("name", "text");
	QueryBuilder qbmp = QueryBuilders.matchPhraseQuery("name", "text");
	QueryBuilder qb1 = QueryBuilders.termQuery(ITQCoreOntology.TUPLE_SUBJECT_PROPERTY, "");
	QueryBuilder qb2 = QueryBuilders.termQuery(ITQCoreOntology.TUPLE_OBJECT_PROPERTY, "");
	QueryBuilder qb3 = QueryBuilders.termQuery(ITQCoreOntology.INSTANCE_OF_PROPERTY_TYPE, "");
	qb.must(qb3);
	qb.should(qb1);
	qb.should(qb2);
	QueryBuilder partial = QueryBuilders.regexpQuery("name", "regexp");
	QueryBuilder wildcard = QueryBuilders.wildcardQuery("name", "query");
}
 

import org.elasticsearch.index.query.QueryBuilders; //导入方法依赖的package包/类
public String fullTextQuerySingleField(String textQuery, boolean isPhraseQuery,
				String fieldName, int start, int count) {
	QueryBuilder qb;
	if (!isPhraseQuery)
		qb = QueryBuilders.matchQuery(fieldName, textQuery);
	else
		qb = QueryBuilders.matchPhraseQuery(fieldName, textQuery);
	SearchSourceBuilder ssb = new SearchSourceBuilder();
	ssb.query(qb);
	ssb.from(start);
	if (count > -1)
		ssb.size(count);
	
	return ssb.toString();
}
 

import org.elasticsearch.index.query.QueryBuilders; //导入方法依赖的package包/类
private static void buildQuery(SearchRequestBuilder requestBuilder) {
  requestBuilder
      .setFrom(0)
      .setSize(5)
      .addSort("@timestamp", SortOrder.DESC);
  BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
  QueryBuilder regexpQuery = QueryBuilders.matchQuery("operation", "账号密码登录");
  queryBuilder.must(regexpQuery);

  requestBuilder.setQuery(queryBuilder);
}
 

import org.elasticsearch.index.query.QueryBuilders; //导入方法依赖的package包/类
private static MatchQueryBuilder createMatchQuery(String name, Object text, Float boost) {
  if (isNotNull(boost)) {
    return QueryBuilders.matchQuery(name, text).boost(boost);
  } else {
    return QueryBuilders.matchQuery(name, text);
  }
}
 

import org.elasticsearch.index.query.QueryBuilders; //导入方法依赖的package包/类
@Test
public void testForClient() throws Exception {
    FunctionScoreQueryBuilder.FilterFunctionBuilder[] functions = {
            new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                    QueryBuilders.matchQuery("name", "kimchy"),
                    ScoreFunctionBuilders. randomFunction("ABCDEF")),
            new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                    ScoreFunctionBuilders.exponentialDecayFunction("age", 0L, 1L))
    };
    QueryBuilder qb = QueryBuilders.functionScoreQuery(functions);
    client.prepareSearch().setQuery(qb).execute().actionGet();
}
 

import org.elasticsearch.index.query.QueryBuilders; //导入方法依赖的package包/类
public void testSingleField() throws NoSuchFieldException, IllegalAccessException {
    SearchResponse searchResponse = client().prepareSearch("test")
            .setQuery(randomizeType(multiMatchQuery("15", "skill"))).get();
    assertNoFailures(searchResponse);
    assertFirstHit(searchResponse, hasId("theone"));

    searchResponse = client().prepareSearch("test")
            .setQuery(randomizeType(multiMatchQuery("15", "skill", "int-field")).analyzer("category")).get();
    assertNoFailures(searchResponse);
    assertFirstHit(searchResponse, hasId("theone"));

    String[] fields = { "full_name", "first_name", "last_name", "last_name_phrase", "first_name_phrase", "category_phrase", "category",
            "missing_field", "missing_fields*" };

    String[] query = {"marvel","hero", "captain",  "america", "15", "17", "1", "5", "ultimate", "Man",
            "marvel", "wolferine", "ninja"};

    // check if it's equivalent to a match query.
    int numIters = scaledRandomIntBetween(10, 100);
    for (int i = 0; i < numIters; i++) {
        String field = RandomPicks.randomFrom(random(), fields);
        int numTerms = randomIntBetween(1, query.length);
        StringBuilder builder = new StringBuilder();
        for (int j = 0; j < numTerms; j++) {
            builder.append(RandomPicks.randomFrom(random(), query)).append(" ");
        }
        MultiMatchQueryBuilder multiMatchQueryBuilder = randomizeType(multiMatchQuery(builder.toString(), field));
        SearchResponse multiMatchResp = client().prepareSearch("test")
                // _uid sort field is a tie, in case hits have the same score,
                // the hits will be sorted the same consistently
                .addSort("_score", SortOrder.DESC)
                .addSort("_uid", SortOrder.ASC)
                .setQuery(multiMatchQueryBuilder).get();
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery(field, builder.toString());
        if (multiMatchQueryBuilder.getType() != null) {
            matchQueryBuilder.type(MatchQuery.Type.valueOf(multiMatchQueryBuilder.getType().matchQueryType().toString()));
        }
        SearchResponse matchResp = client().prepareSearch("test")
                // _uid tie sort
                .addSort("_score", SortOrder.DESC)
                .addSort("_uid", SortOrder.ASC)
                .setQuery(matchQueryBuilder).get();
        assertThat("field: " + field + " query: " + builder.toString(), multiMatchResp.getHits().getTotalHits(), equalTo(matchResp.getHits().getTotalHits()));
        SearchHits hits = multiMatchResp.getHits();
        if (field.startsWith("missing")) {
            assertEquals(0, hits.getHits().length);
        }
        for (int j = 0; j < hits.getHits().length; j++) {
            assertThat(hits.getHits()[j].getScore(), equalTo(matchResp.getHits().getHits()[j].getScore()));
            assertThat(hits.getHits()[j].getId(), equalTo(matchResp.getHits().getHits()[j].getId()));
        }
    }

}
 

import org.elasticsearch.index.query.QueryBuilders; //导入方法依赖的package包/类
public void testHighlightNoMatchSizeNumberOfFragments() throws IOException {
    assertAcked(prepareCreate("test").addMapping("type1",
            "text", "type=text," + randomStoreField() + "term_vector=with_positions_offsets,index_options=offsets"));
    ensureGreen();

    String text1 = "This is the first sentence. This is the second sentence." + HighlightUtils.PARAGRAPH_SEPARATOR;
    String text2 = "This is the third sentence. This is the fourth sentence.";
    String text3 = "This is the fifth sentence";
    index("test", "type1", "1", "text", new String[] {text1, text2, text3});
    refresh();

    // The no match fragment should come from the first value of a multi-valued field
    HighlightBuilder.Field field = new HighlightBuilder.Field("text")
            .fragmentSize(1)
            .numOfFragments(0)
            .highlighterType("plain")
            .noMatchSize(20);
    SearchResponse response = client().prepareSearch("test").highlighter(new HighlightBuilder().field(field)).get();
    assertHighlight(response, 0, "text", 0, 1, equalTo("This is the first"));

    field.highlighterType("fvh");
    response = client().prepareSearch("test").highlighter(new HighlightBuilder().field(field)).get();
    assertHighlight(response, 0, "text", 0, 1, equalTo("This is the first sentence"));

    // Postings hl also works but the fragment is the whole first sentence (size ignored)
    field.highlighterType("postings");
    response = client().prepareSearch("test").highlighter(new HighlightBuilder().field(field)).get();
    assertHighlight(response, 0, "text", 0, 1, equalTo("This is the first sentence."));

    // Unified hl also works but the fragment is the whole first sentence (size ignored)
    field.highlighterType("unified");
    response = client().prepareSearch("test").highlighter(new HighlightBuilder().field(field)).get();
    assertHighlight(response, 0, "text", 0, 1, equalTo("This is the first sentence."));

    //if there's a match we only return the values with matches (whole value as number_of_fragments == 0)
    MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("text", "third fifth");
    field.highlighterType("plain");
    response = client().prepareSearch("test").setQuery(queryBuilder).highlighter(new HighlightBuilder().field(field)).get();
    assertHighlight(response, 0, "text", 0, 2, equalTo("This is the <em>third</em> sentence. This is the fourth sentence."));
    assertHighlight(response, 0, "text", 1, 2, equalTo("This is the <em>fifth</em> sentence"));

    field.highlighterType("fvh");
    response = client().prepareSearch("test").setQuery(queryBuilder).highlighter(new HighlightBuilder().field(field)).get();
    assertHighlight(response, 0, "text", 0, 2, equalTo("This is the <em>third</em> sentence. This is the fourth sentence."));
    assertHighlight(response, 0, "text", 1, 2, equalTo("This is the <em>fifth</em> sentence"));

    field.highlighterType("postings");
    response = client().prepareSearch("test").setQuery(queryBuilder).highlighter(new HighlightBuilder().field(field)).get();
    assertHighlight(response, 0, "text", 0, 2, equalTo("This is the <em>third</em> sentence. This is the fourth sentence."));
    assertHighlight(response, 0, "text", 1, 2, equalTo("This is the <em>fifth</em> sentence"));

    field.highlighterType("unified");
    response = client().prepareSearch("test").setQuery(queryBuilder).highlighter(new HighlightBuilder().field(field)).get();
    assertHighlight(response, 0, "text", 0, 2, equalTo("This is the <em>third</em> sentence. This is the fourth sentence."));
    assertHighlight(response, 0, "text", 1, 2, equalTo("This is the <em>fifth</em> sentence"));
}
 

import org.elasticsearch.index.query.QueryBuilders; //导入方法依赖的package包/类
private static QueryBuilder contains(String fieldName, String value) {
  return QueryBuilders.matchQuery(fieldName, value);
}