@Override protected void addClause(BooleanQuery.Builder topLevel, Term term, int docCount, float boost, TermContext states) { final TermQuery tq = new TermQuery(term, states); topLevel.add(new BoostQuery(tq, boost), BooleanClause.Occur.SHOULD); } }
return new BoostQuery(new ConstantScoreQuery(query), 0); case MUST_NOT: while (query instanceof BoostQuery) { BoostQuery bq = (BoostQuery) query; boost *= bq.getBoost(); query = bq.getQuery(); float boost = entry.getValue().floatValue(); if (boost != 1f) { query = new BoostQuery(query, boost); while (query instanceof BoostQuery) { BoostQuery bq = (BoostQuery) query; boost *= bq.getBoost(); query = bq.getQuery(); float boost = entry.getValue().floatValue(); if (boost != 1f) { query = new BoostQuery(query, boost); if (must instanceof BoostQuery) { BoostQuery boostQuery = (BoostQuery) must; must = boostQuery.getQuery(); boost = boostQuery.getBoost(); rewritten = new ConstantScoreQuery(rewritten); if (boost != 1f) { rewritten = new BoostQuery(rewritten, boost);
@Override public int hashCode() { int h = classHash(); h = 31 * h + query.hashCode(); h = 31 * h + Float.floatToIntBits(boost); return h; }
/** * Add to an existing boolean query the More Like This query from this PriorityQueue */ private void addToQuery(PriorityQueue<ScoreTerm> q, BooleanQuery.Builder query) { ScoreTerm scoreTerm; float bestScore = -1; while ((scoreTerm = q.pop()) != null) { Query tq = new TermQuery(new Term(scoreTerm.topField, scoreTerm.word)); if (boost) { if (bestScore == -1) { bestScore = (scoreTerm.score); } float myScore = (scoreTerm.score); tq = new BoostQuery(tq, boostFactor * myScore / bestScore); } try { query.add(tq, BooleanClause.Occur.SHOULD); } catch (BooleanQuery.TooManyClauses ignore) { break; } } }
/** * Add a clause to a boolean query. */ private static void add(BooleanQuery.Builder q, String name, String value, float boost) { Query tq = new TermQuery(new Term(name, value)); q.add(new BooleanClause(new BoostQuery(tq, boost), BooleanClause.Occur.SHOULD)); }
@Override protected Query topLevelQuery(Term[] terms, TermContext[] ctx, int[] docFreqs, int maxDoc) { BooleanQuery.Builder highBuilder = new BooleanQuery.Builder(); BooleanQuery.Builder lowBuilder = new BooleanQuery.Builder(); for (int i = 0; i < terms.length; i++) { Query query = new TermQuery(terms[i], ctx[i]); if (boosts != null && boosts[i] != 1f) { query = new BoostQuery(query, boosts[i]); highBuilder.add(query, BooleanClause.Occur.SHOULD); } else { lowBuilder.add(query, BooleanClause.Occur.SHOULD); BooleanQuery high = highBuilder.build(); BooleanQuery low = lowBuilder.build(); if (low.clauses().isEmpty()) { BooleanQuery.Builder queryBuilder = new BooleanQuery.Builder(); for (BooleanClause booleanClause : high) { queryBuilder.add(booleanClause.getQuery(), Occur.MUST); return queryBuilder.build(); } else if (high.clauses().isEmpty()) { return low; } else {
/** * Factory method to generate a fuzzy query. */ protected Query newFuzzyQuery(String text, int fuzziness) { BooleanQuery.Builder bq = new BooleanQuery.Builder(); bq.setDisableCoord(true); for (Map.Entry<String,Float> entry : weights.entrySet()) { Query q = new FuzzyQuery(new Term(entry.getKey(), text), fuzziness); float boost = entry.getValue(); if (boost != 1f) { q = new BoostQuery(q, boost); } bq.add(q, BooleanClause.Occur.SHOULD); } return simplify(bq.build()); }
return mightMatchNonNestedDocs(((ConstantScoreQuery) query).getQuery(), nestedPath); } else if (query instanceof BoostQuery) { return mightMatchNonNestedDocs(((BoostQuery) query).getQuery(), nestedPath); } else if (query instanceof MatchAllDocsQuery) { return true; return false; } else if (query instanceof TermQuery) { return mightMatchNonNestedDocs(((TermQuery) query).getTerm().field(), nestedPath); } else if (query instanceof TermInSetQuery) { PrefixCodedTerms terms = ((TermInSetQuery) query).getTermData(); } 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));
@Test @SuppressWarnings("unchecked") public void testBoostQuery() { try ( Session session = openSession() ) { FullTextSession fullTextSession = Search.getFullTextSession( session ); TermQuery termQuery = new TermQuery( new Term( "message", "import" ) ); termQuery.setBoost( 3.0f ); BoostQuery testedQuery = new BoostQuery( termQuery, 2.0f ); FullTextQuery fullTextQuery = fullTextSession.createFullTextQuery( testedQuery, Letter.class ); String queryString = fullTextQuery.getQueryString(); assertJsonEquals( "{'query':{'bool':{'must':{'term':{'message':{'value':'import','boost':3.0}}},'boost':2.0}}}", queryString ); List<Letter> letters = fullTextQuery.list(); assertThat( letters ).hasSize( 1 ); assertThat( letters ).extracting( "message" ).containsExactly( "Important letter" ); } }
SpanQuery[] allSpanClauses = new SpanQuery[bq.clauses().size()]; Query qc = clause.getQuery(); if (clause.getOccur().equals(BooleanClause.Occur.MUST_NOT)) { numNegatives++; qc = ((BoostQuery) qc).getQuery(); allSpanClauses[i] = new SpanTermQuery(new Term(field, "Dummy clause because no terms found - must match nothing")); if (qc instanceof TermQuery) { TermQuery tq = (TermQuery) qc; allSpanClauses[i] = new SpanTermQuery(tq.getTerm()); } else { throw new IllegalArgumentException("Unknown query type \"" i = 0; for (BooleanClause clause : bq) { if (!clause.getOccur().equals(BooleanClause.Occur.MUST_NOT)) { positiveClauses.add(allSpanClauses[i]);
} else if (subQuery instanceof BoostQuery) { BoostQuery boostQuery = (BoostQuery) subQuery; subQuery = boostQuery.getQuery(); boost *= boostQuery.getBoost(); } else { break; PrefixQuery prefixQuery = new PrefixQuery(new Term(fieldName, prefixBuilder.value())); if (prefixBuilder.rewrite() != null) { MultiTermQuery.RewriteMethod rewriteMethod = SpanTermQuery spanTermQuery = new SpanTermQuery(((TermQuery) subQuery).getTerm()); spanQuery = new FieldMaskingSpanQuery(spanTermQuery, fieldName);
@Override @JsonIgnore final public Query getQuery(final QueryContext queryContext) throws IOException { final BooleanQuery.Builder builder = new BooleanQuery.Builder(); final String resolvedField = resolveField(queryContext.getFieldMap()); try (final TokenStream tokenStream = queryContext.getQueryAnalyzer().tokenStream(resolvedField, query_string)) { final CharTermAttribute charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class); final PositionIncrementAttribute pocincrAttribute = tokenStream.getAttribute(PositionIncrementAttribute.class); tokenStream.reset(); int pos = 0; while (tokenStream.incrementToken()) { final String charTerm = charTermAttribute.toString(); int start = pos - distance; if (start < 0) start = 0; final int end = pos + distance + 1; for (int i = start; i < end; i++) { final float dist = Math.abs(i - pos) + 1; final float boost = 1 / dist; final SpanTermQuery spanTermQuery = new SpanTermQuery(new Term(resolvedField, charTerm)); Query query = new BoostQuery(new SpanPositionRangeQuery(spanTermQuery, i, i + 1), boost); builder.add(new BooleanClause(query, BooleanClause.Occur.SHOULD)); } pos += pocincrAttribute.getPositionIncrement(); } return builder.build(); } }
/** * Expand a {@link PhraseQuery} to multiple fields that share the same analyzer. * Returns a {@link DisjunctionMaxQuery} with a disjunction for each expanded field. */ static Query blendPhrase(PhraseQuery query, float tiebreaker, FieldAndFieldType... fields) { List<Query> disjunctions = new ArrayList<>(); for (FieldAndFieldType field : fields) { int[] positions = query.getPositions(); Term[] terms = query.getTerms(); PhraseQuery.Builder builder = new PhraseQuery.Builder(); for (int i = 0; i < terms.length; i++) { builder.add(new Term(field.fieldType.name(), terms[i].bytes()), positions[i]); } Query q = builder.build(); if (field.boost != AbstractQueryBuilder.DEFAULT_BOOST) { q = new BoostQuery(q, field.boost); } disjunctions.add(q); } return new DisjunctionMaxQuery(disjunctions, tiebreaker); }
termQuery = ((BoostQuery) termQuery).getQuery(); } else if (termQuery instanceof TypeFieldMapper.TypesQuery) { assert ((TypeFieldMapper.TypesQuery) termQuery).getTerms().length == 1; return new Term(TypeFieldMapper.NAME, ((TypeFieldMapper.TypesQuery) termQuery).getTerms()[0]); TermIterator it = terms.iterator(); BytesRef term = it.next(); return new Term(it.field(), term); + termQuery.getClass() + ": " + termQuery); return ((TermQuery) termQuery).getTerm();
} else if (sourceQuery instanceof BoostQuery) { BoostQuery bq = (BoostQuery) sourceQuery; sourceQuery = bq.getQuery(); boost *= bq.getBoost(); } else { break; BooleanQuery bq = (BooleanQuery)sourceQuery; for( BooleanClause clause : bq ) { if( !clause.isProhibited() ) { flatten( clause.getQuery(), reader, flatQueries, boost ); sourceQuery = new BoostQuery(sourceQuery, boost); PhraseQuery pq = (PhraseQuery)sourceQuery; if( pq.getTerms().length == 1 ) sourceQuery = new TermQuery( pq.getTerms()[0] ); if (boost != 1f) { sourceQuery = new BoostQuery(sourceQuery, boost);
if (sourceQuery instanceof BoostQuery) { BoostQuery bq = (BoostQuery) sourceQuery; sourceQuery = bq.getQuery(); boost *= bq.getBoost(); flatten(sourceQuery, reader, flatQueries, boost); } else if (sourceQuery instanceof SpanTermQuery) { super.flatten(new TermQuery(((SpanTermQuery) sourceQuery).getTerm()), reader, flatQueries, boost); } else if (sourceQuery instanceof ConstantScoreQuery) { flatten(((ConstantScoreQuery) sourceQuery).getQuery(), reader, flatQueries, boost); flatten(new TermQuery(term), reader, flatQueries, boost);
void saveTerms( Collection<Query> flatQueries, IndexReader reader ) throws IOException{ for( Query query : flatQueries ){ while (query instanceof BoostQuery) { query = ((BoostQuery) query).getQuery(); } Set<String> termSet = getTermSet( query ); if( query instanceof TermQuery ) termSet.add( ((TermQuery)query).getTerm().text() ); else if( query instanceof PhraseQuery ){ for( Term term : ((PhraseQuery)query).getTerms() ) termSet.add( term.text() ); } else if (query instanceof MultiTermQuery && reader != null) { BooleanQuery mtqTerms = (BooleanQuery) query.rewrite(reader); for (BooleanClause clause : mtqTerms) { termSet.add (((TermQuery) clause.getQuery()).getTerm().text()); } } else throw new RuntimeException( "query \"" + query.toString() + "\" must be flatten first." ); } }
return applySynonymQueries(((BoostedQuery) query).getQuery(), synonymQueries, originalBoost, synonymBoost); } else if (query instanceof BooleanQuery) { BooleanQuery.Builder booleanQueryBuilder = new BooleanQuery.Builder(); for (BooleanClause booleanClause : ((BooleanQuery) query).clauses()) { if (Occur.MUST == booleanClause.getOccur()) { BooleanQuery.Builder combinedQueryBuilder = new BooleanQuery.Builder(); combinedQueryBuilder.add(new BoostQuery(booleanClause.getQuery(), originalBoost), Occur.SHOULD); BooleanQuery.Builder booleanSynonymQueryBuilder = new BooleanQuery.Builder(); booleanSynonymQueryBuilder.add(new BoostQuery(synonymQuery, synonymBoost), Occur.SHOULD); combinedQueryBuilder.add(booleanSynonymQueryBuilder.build(), Occur.SHOULD);