Java BoostQuery类代码示例

import org.apache.lucene.search.BoostQuery; //导入依赖的package包/类
/**
 * Checks the result of {@link QueryBuilder#toQuery(QueryShardContext)} given the original {@link QueryBuilder}
 * and {@link QueryShardContext}. Verifies that named queries and boost are properly handled and delegates to
 * {@link #doAssertLuceneQuery(AbstractQueryBuilder, Query, SearchContext)} for query specific checks.
 */
private void assertLuceneQuery(QB queryBuilder, Query query, SearchContext context) throws IOException {
    if (queryBuilder.queryName() != null) {
        Query namedQuery = context.getQueryShardContext().copyNamedQueries().get(queryBuilder.queryName());
        assertThat(namedQuery, equalTo(query));
    }
    if (query != null) {
        if (queryBuilder.boost() != AbstractQueryBuilder.DEFAULT_BOOST) {
            assertThat(query, either(instanceOf(BoostQuery.class)).or(instanceOf(SpanBoostQuery.class)));
            if (query instanceof SpanBoostQuery) {
                SpanBoostQuery spanBoostQuery = (SpanBoostQuery) query;
                assertThat(spanBoostQuery.getBoost(), equalTo(queryBuilder.boost()));
                query = spanBoostQuery.getQuery();
            } else {
                BoostQuery boostQuery = (BoostQuery) query;
                assertThat(boostQuery.getBoost(), equalTo(queryBuilder.boost()));
                query = boostQuery.getQuery();
            }
        }
    }
    doAssertLuceneQuery(queryBuilder, query, context);
}
 

import org.apache.lucene.search.BoostQuery; //导入依赖的package包/类
public void testToQueryWithStringField() throws IOException {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    String query = "{\n" +
            "    \"fuzzy\":{\n" +
            "        \"" + STRING_FIELD_NAME + "\":{\n" +
            "            \"value\":\"sh\",\n" +
            "            \"fuzziness\": \"AUTO\",\n" +
            "            \"prefix_length\":1,\n" +
            "            \"boost\":2.0\n" +
            "        }\n" +
            "    }\n" +
            "}";
    Query parsedQuery = parseQuery(query).toQuery(createShardContext());
    assertThat(parsedQuery, instanceOf(BoostQuery.class));
    BoostQuery boostQuery = (BoostQuery) parsedQuery;
    assertThat(boostQuery.getBoost(), equalTo(2.0f));
    assertThat(boostQuery.getQuery(), instanceOf(FuzzyQuery.class));
    FuzzyQuery fuzzyQuery = (FuzzyQuery) boostQuery.getQuery();
    assertThat(fuzzyQuery.getTerm(), equalTo(new Term(STRING_FIELD_NAME, "sh")));
    assertThat(fuzzyQuery.getMaxEdits(), equalTo(Fuzziness.AUTO.asDistance("sh")));
    assertThat(fuzzyQuery.getPrefixLength(), equalTo(1));
}
 

import org.apache.lucene.search.BoostQuery; //导入依赖的package包/类
public void testToQueryPhraseQueryBoostAndSlop() throws IOException {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    QueryStringQueryBuilder queryStringQueryBuilder =
        new QueryStringQueryBuilder("\"test phrase\"~2").field(STRING_FIELD_NAME, 5f);
    Query query = queryStringQueryBuilder.toQuery(createShardContext());
    assertThat(query, instanceOf(DisjunctionMaxQuery.class));
    DisjunctionMaxQuery disjunctionMaxQuery = (DisjunctionMaxQuery) query;
    assertThat(disjunctionMaxQuery.getDisjuncts().size(), equalTo(1));
    assertThat(disjunctionMaxQuery.getDisjuncts().get(0), instanceOf(BoostQuery.class));
    BoostQuery boostQuery = (BoostQuery) disjunctionMaxQuery.getDisjuncts().get(0);
    assertThat(boostQuery.getBoost(), equalTo(5f));
    assertThat(boostQuery.getQuery(), instanceOf(PhraseQuery.class));
    PhraseQuery phraseQuery = (PhraseQuery) boostQuery.getQuery();
    assertThat(phraseQuery.getSlop(), Matchers.equalTo(2));
    assertThat(phraseQuery.getTerms().length, equalTo(2));
}
 

import org.apache.lucene.search.BoostQuery; //导入依赖的package包/类
public void testToQueryBoost() throws IOException {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    QueryShardContext shardContext = createShardContext();
    MultiMatchQueryBuilder multiMatchQueryBuilder = new MultiMatchQueryBuilder("test");
    multiMatchQueryBuilder.field(STRING_FIELD_NAME, 5f);
    Query query = multiMatchQueryBuilder.toQuery(shardContext);
    assertTermOrBoostQuery(query, STRING_FIELD_NAME, "test", 5f);

    multiMatchQueryBuilder = new MultiMatchQueryBuilder("test");
    multiMatchQueryBuilder.field(STRING_FIELD_NAME, 5f);
    multiMatchQueryBuilder.boost(2f);
    query = multiMatchQueryBuilder.toQuery(shardContext);
    assertThat(query, instanceOf(BoostQuery.class));
    BoostQuery boostQuery = (BoostQuery) query;
    assertThat(boostQuery.getBoost(), equalTo(2f));
    assertTermOrBoostQuery(boostQuery.getQuery(), STRING_FIELD_NAME, "test", 5f);
}
 

import org.apache.lucene.search.BoostQuery; //导入依赖的package包/类
public void testCrossFieldMultiMatchQuery() throws IOException {
    QueryShardContext queryShardContext = indexService.newQueryShardContext(
            randomInt(20), null, () -> { throw new UnsupportedOperationException(); });
    queryShardContext.setAllowUnmappedFields(true);
    Query parsedQuery = multiMatchQuery("banon").field("name.first", 2).field("name.last", 3).field("foobar").type(MultiMatchQueryBuilder.Type.CROSS_FIELDS).toQuery(queryShardContext);
    try (Engine.Searcher searcher = indexService.getShard(0).acquireSearcher("test")) {
        Query rewrittenQuery = searcher.searcher().rewrite(parsedQuery);

        BooleanQuery.Builder expected = new BooleanQuery.Builder();
        expected.add(new TermQuery(new Term("foobar", "banon")), BooleanClause.Occur.SHOULD);
        Query tq1 = new BoostQuery(new TermQuery(new Term("name.first", "banon")), 2);
        Query tq2 = new BoostQuery(new TermQuery(new Term("name.last", "banon")), 3);
        expected.add(new DisjunctionMaxQuery(Arrays.<Query>asList(tq1, tq2), 0f), BooleanClause.Occur.SHOULD);
        assertEquals(expected.build(), rewrittenQuery);
    }
}
 

import org.apache.lucene.search.BoostQuery; //导入依赖的package包/类
public void testBlendNoTermQuery() {
    FakeFieldType ft1 = new FakeFieldType();
    ft1.setName("foo");
    FakeFieldType ft2 = new FakeFieldType() {
        @Override
        public Query termQuery(Object value, QueryShardContext context) {
            return new MatchAllDocsQuery();
        }
    };
    ft2.setName("bar");
    Term[] terms = new Term[] { new Term("foo", "baz") };
    float[] boosts = new float[] {2};
    Query expectedClause1 = BlendedTermQuery.booleanBlendedQuery(terms, boosts, false);
    Query expectedClause2 = new BoostQuery(new MatchAllDocsQuery(), 3);
    Query expected = new BooleanQuery.Builder().setDisableCoord(true)
            .add(expectedClause1, Occur.SHOULD)
            .add(expectedClause2, Occur.SHOULD)
            .build();
    Query actual = MultiMatchQuery.blendTerm(
            indexService.newQueryShardContext(randomInt(20), null, () -> { throw new UnsupportedOperationException(); }),
            new BytesRef("baz"), null, 1f, new FieldAndFieldType(ft1, 2), new FieldAndFieldType(ft2, 3));
    assertEquals(expected, actual);
}
 

import org.apache.lucene.search.BoostQuery; //导入依赖的package包/类
@Test
public void testBoost() throws Exception {
	CharacterRunAutomaton stopWords = new CharacterRunAutomaton(Automata.makeString("on"));
	Analyzer oneStopAnalyzer = new MockAnalyzer(random(), MockTokenizer.SIMPLE, true, stopWords);
	QueryParser qp = getParserConfig(oneStopAnalyzer);
	Query q = getQuery("on^1.0", qp);
	Assert.assertNotNull(q);
	q = getQuery("\"hello\"^2.0", qp);
	Assert.assertNotNull(q);
	Assert.assertEquals(((BoostQuery) q).getBoost(), (float) 2.0, (float) 0.5);
	q = getQuery("hello^2.0", qp);
	Assert.assertNotNull(q);
	Assert.assertEquals(((BoostQuery) q).getBoost(), (float) 2.0, (float) 0.5);
	q = getQuery("\"on\"^1.0", qp);
	Assert.assertNotNull(q);

	Analyzer a2 = new MockAnalyzer(random(), MockTokenizer.SIMPLE, true, MockTokenFilter.ENGLISH_STOPSET);
	QueryParser qp2 = getParserConfig(a2);
	q = getQuery("the^3", qp2);
	// "the" is a stop word so the result is an empty query:
	Assert.assertNotNull(q);
	assertMatchNoDocsQuery(q);
	Assert.assertFalse(q instanceof BoostQuery);
}
 

import org.apache.lucene.search.BoostQuery; //导入依赖的package包/类
@Test
public void testStopwords() throws Exception {
	CharacterRunAutomaton stopSet = new CharacterRunAutomaton(new RegExp("the|foo").toAutomaton());
	QueryParser qp = getParserConfig(new MockAnalyzer(random(), MockTokenizer.SIMPLE, true, stopSet));
	Query result = getQuery("field:the OR field:foo", qp);
	Assert.assertNotNull("result is null and it shouldn't be", result);
	Assert.assertTrue("result is not a BooleanQuery",
			result instanceof BooleanQuery || result instanceof MatchNoDocsQuery);
	if (result instanceof BooleanQuery) {
		Assert.assertEquals(0, ((BooleanQuery) result).clauses().size());
	}
	result = getQuery("field:woo OR field:the", qp);
	Assert.assertNotNull("result is null and it shouldn't be", result);
	Assert.assertTrue("result is not a TermQuery", result instanceof TermQuery);
	result = getQuery("(fieldX:xxxxx OR fieldy:xxxxxxxx)^2 AND (fieldx:the OR fieldy:foo)", qp);
	Assert.assertNotNull("result is null and it shouldn't be", result);
	Assert.assertTrue("result is not a BoostQuery", result instanceof BoostQuery);
	result = ((BoostQuery) result).getQuery();
	Assert.assertTrue("result is not a BooleanQuery", result instanceof BooleanQuery);
	if (VERBOSE)
		System.out.println("Result: " + result);
	Assert.assertTrue(((BooleanQuery) result).clauses().size() + " does not equal: " + 2,
			((BooleanQuery) result).clauses().size() == 2);
}
 

import org.apache.lucene.search.BoostQuery; //导入依赖的package包/类
public void testBoost()
    throws Exception {
  CharacterRunAutomaton stopWords = new CharacterRunAutomaton(Automata.makeString("on"));
  Analyzer oneStopAnalyzer = new MockAnalyzer(random(), MockTokenizer.SIMPLE, true, stopWords);
  CommonQueryParserConfiguration qp = getParserConfig(oneStopAnalyzer);
  Query q = getQuery("on^1.0",qp);
  assertNotNull(q);
  q = getQuery("\"hello\"^2.0",qp);
  assertNotNull(q);

  assertEquals(getBoost(q), (float) 2.0, (float) 0.5);
  q = getQuery("hello^2.0",qp);
  assertNotNull(q);
  assertEquals(((BoostQuery)q).getBoost(), (float) 2.0, (float) 0.5);
  q = getQuery("\"on\"^1.0",qp);
  assertNotNull(q);

  Analyzer a2 = new MockAnalyzer(random(), MockTokenizer.SIMPLE, true, MockTokenFilter.ENGLISH_STOPSET);
  CommonQueryParserConfiguration qp2 = getParserConfig(a2);
  q = getQuery("the^3", qp2);
  // "the" is a stop word so the result is an empty query:
  assertNotNull(q);
  assertEmpty(q);
  assertEquals(1.0f, getBoost(q), 0.01f);
}
 

import org.apache.lucene.search.BoostQuery; //导入依赖的package包/类
public void testStopwords() throws Exception {
  CharacterRunAutomaton stopSet = new CharacterRunAutomaton(new RegExp("the|foo").toAutomaton());
  CommonQueryParserConfiguration qp = getParserConfig(new MockAnalyzer(random(), MockTokenizer.SIMPLE, true, stopSet));
  Query result = getQuery("field:the OR field:foo",qp);
  assertNotNull("result is null and it shouldn't be", result);
  System.out.println(result.getClass());
  assertTrue("result is not a BooleanQuery", result instanceof SpanOrQuery || result instanceof BooleanQuery || result instanceof MatchNoDocsQuery);
  if (result instanceof BooleanQuery) {
    assertEquals(0, ((BooleanQuery) result).clauses().size());
  }
  result = getQuery("field:woo OR field:the",qp);
  assertNotNull("result is null and it shouldn't be", result);
  assertTrue("result is not a TermQuery", result instanceof TermQuery);
  result = getQuery("(fieldX:xxxxx OR fieldy:xxxxxxxx)^2 AND (fieldx:the OR fieldy:foo)",qp);
  assertNotNull("result is null and it shouldn't be", result);
  assertTrue("result is not a BoostQuery", result instanceof BoostQuery);
  result = ((BoostQuery) result).getQuery();
  assertTrue("result is not a BooleanQuery", result instanceof BooleanQuery);
  if (VERBOSE) System.out.println("Result: " + result);
  assertTrue(((BooleanQuery) result).clauses().size() + " does not equal: " + 2, ((BooleanQuery) result).clauses().size() == 2);
}
 

import org.apache.lucene.search.BoostQuery; //导入依赖的package包/类
public void testExtractQueryMetadata_boostQuery() {
    TermQuery termQuery1 = new TermQuery(new Term("_field", "_term"));
    BoostQuery constantScoreQuery = new BoostQuery(termQuery1, 1f);
    Result result = analyze(constantScoreQuery);
    assertThat(result.verified, is(true));
    List<Term> terms = new ArrayList<>(result.terms);
    assertThat(terms.size(), equalTo(1));
    assertThat(terms.get(0).field(), equalTo(termQuery1.getTerm().field()));
    assertThat(terms.get(0).bytes(), equalTo(termQuery1.getTerm().bytes()));
}
 

import org.apache.lucene.search.BoostQuery; //导入依赖的package包/类
protected static void assertTermOrBoostQuery(Query query, String field, String value, float fieldBoost) {
    if (fieldBoost != AbstractQueryBuilder.DEFAULT_BOOST) {
        assertThat(query, instanceOf(BoostQuery.class));
        BoostQuery boostQuery = (BoostQuery) query;
        assertThat(boostQuery.getBoost(), equalTo(fieldBoost));
        query = boostQuery.getQuery();
    }
    assertTermQuery(query, field, value);
}
 

import org.apache.lucene.search.BoostQuery; //导入依赖的package包/类
private Query applyBoost(String field, Query q) {
    Float fieldBoost = settings.fieldsAndWeights().get(field);
    if (fieldBoost != null && fieldBoost != 1f) {
        return new BoostQuery(q, fieldBoost);
    }
    return q;
}
 

import org.apache.lucene.search.BoostQuery; //导入依赖的package包/类
/** Returns true if the given query might match nested documents. */
public boolean mightMatchNestedDocs(Query query) {
    if (query instanceof ConstantScoreQuery) {
        return mightMatchNestedDocs(((ConstantScoreQuery) query).getQuery());
    } else if (query instanceof BoostQuery) {
        return mightMatchNestedDocs(((BoostQuery) query).getQuery());
    } else if (query instanceof MatchAllDocsQuery) {
        return true;
    } else if (query instanceof MatchNoDocsQuery) {
        return false;
    } else if (query instanceof TermQuery) {
        // We only handle term queries and range queries, which should already
        // cover a high majority of use-cases
        return mightMatchNestedDocs(((TermQuery) query).getTerm().field());
    } else if (query instanceof PointRangeQuery) {
        return mightMatchNestedDocs(((PointRangeQuery) query).getField());
    } else if (query instanceof IndexOrDocValuesQuery) {
        return mightMatchNestedDocs(((IndexOrDocValuesQuery) query).getIndexQuery());
    } else if (query instanceof BooleanQuery) {
        final BooleanQuery bq = (BooleanQuery) query;
        final boolean hasRequiredClauses = bq.clauses().stream().anyMatch(BooleanClause::isRequired);
        if (hasRequiredClauses) {
            return bq.clauses().stream()
                    .filter(BooleanClause::isRequired)
                    .map(BooleanClause::getQuery)
                    .allMatch(this::mightMatchNestedDocs);
        } else {
            return bq.clauses().stream()
                    .filter(c -> c.getOccur() == Occur.SHOULD)
                    .map(BooleanClause::getQuery)
                    .anyMatch(this::mightMatchNestedDocs);
        }
    } else if (query instanceof ESToParentBlockJoinQuery) {
        return ((ESToParentBlockJoinQuery) query).getPath() != null;
    } else {
        return true;
    }
}
 

import org.apache.lucene.search.BoostQuery; //导入依赖的package包/类
/** Returns true if the given query might match parent documents or documents
 *  that are nested under a different path. */
public boolean mightMatchNonNestedDocs(Query query, String nestedPath) {
    if (query instanceof ConstantScoreQuery) {
        return mightMatchNonNestedDocs(((ConstantScoreQuery) query).getQuery(), nestedPath);
    } else if (query instanceof BoostQuery) {
        return mightMatchNonNestedDocs(((BoostQuery) query).getQuery(), nestedPath);
    } else if (query instanceof MatchAllDocsQuery) {
        return true;
    } else if (query instanceof MatchNoDocsQuery) {
        return false;
    } else if (query instanceof TermQuery) {
        return mightMatchNonNestedDocs(((TermQuery) query).getTerm().field(), nestedPath);
    } else if (query instanceof PointRangeQuery) {
        return mightMatchNonNestedDocs(((PointRangeQuery) query).getField(), nestedPath);
    } else if (query instanceof IndexOrDocValuesQuery) {
        return mightMatchNonNestedDocs(((IndexOrDocValuesQuery) query).getIndexQuery(), nestedPath);
    } else if (query instanceof BooleanQuery) {
        final BooleanQuery bq = (BooleanQuery) query;
        final boolean hasRequiredClauses = bq.clauses().stream().anyMatch(BooleanClause::isRequired);
        if (hasRequiredClauses) {
            return bq.clauses().stream()
                    .filter(BooleanClause::isRequired)
                    .map(BooleanClause::getQuery)
                    .allMatch(q -> mightMatchNonNestedDocs(q, nestedPath));
        } else {
            return bq.clauses().stream()
                    .filter(c -> c.getOccur() == Occur.SHOULD)
                    .map(BooleanClause::getQuery)
                    .anyMatch(q -> mightMatchNonNestedDocs(q, nestedPath));
        }
    } else {
        return true;
    }
}