/** * Check if a BooleanQuery contains a clause of a given occur type. * * @param query the query to check * @param occur the occur type to check for * @return whether or not the query contains a clause of the specified type */ private boolean hasClause(BooleanQuery query, Occur occur) { for (BooleanClause clause : query) { if (clause.getOccur().equals(occur)) { return true; } } return false; } }
private BooleanQuery(int minimumNumberShouldMatch, BooleanClause[] clauses) { this.minimumNumberShouldMatch = minimumNumberShouldMatch; this.clauses = Collections.unmodifiableList(Arrays.asList(clauses)); clauseSets = new EnumMap<>(Occur.class); // duplicates matter for SHOULD and MUST clauseSets.put(Occur.SHOULD, new Multiset<>()); clauseSets.put(Occur.MUST, new Multiset<>()); // but not for FILTER and MUST_NOT clauseSets.put(Occur.FILTER, new HashSet<>()); clauseSets.put(Occur.MUST_NOT, new HashSet<>()); for (BooleanClause clause : clauses) { clauseSets.get(clause.getOccur()).add(clause.getQuery()); } }
scorers.get(c.getOccur()).add(subScorer);
BulkScorer optionalBulkScorer(LeafReaderContext context) throws IOException { List<BulkScorer> optional = new ArrayList<BulkScorer>(); Iterator<BooleanClause> cIter = query.iterator(); for (Weight w : weights) { BooleanClause c = cIter.next(); if (c.getOccur() != Occur.SHOULD) { continue; } BulkScorer subScorer = w.bulkScorer(context); if (subScorer != null) { optional.add(subScorer); } } if (optional.size() == 0) { return null; } if (query.getMinimumNumberShouldMatch() > optional.size()) { return null; } if (optional.size() == 1) { return optional.get(0); } return new BooleanScorer(this, optional, Math.max(1, query.getMinimumNumberShouldMatch()), needsScores); }
/** * If the query is a BooleanQuery and it contains a single Occur.MUST_NOT * clause it will be returned as is. Otherwise it will be wrapped in a * BooleanClause with the given Occur. */ private BooleanClause createBooleanClause(Query query, Occur occur) { if (query instanceof BooleanQuery) { BooleanClause[] clauses = ((BooleanQuery) query).getClauses(); if (clauses.length == 1 && clauses[0].getOccur().equals(Occur.MUST_NOT)) { return clauses[0]; } } return new BooleanClause(query, occur); }
/** * If the query is a BooleanQuery and it contains a single Occur.MUST_NOT * clause it will be returned as is. Otherwise it will be wrapped in a * BooleanClause with the given Occur. */ private BooleanClause createBooleanClause(Query query, Occur occur) { if (query instanceof BooleanQuery) { BooleanClause[] clauses = ((BooleanQuery) query).getClauses(); if (clauses.length == 1 && clauses[0].getOccur().equals(Occur.MUST_NOT)) { return clauses[0]; } } return new BooleanClause(query, occur); }
/** * If the query is a BooleanQuery and it contains a single Occur.MUST_NOT * clause it will be returned as is. Otherwise it will be wrapped in a * BooleanClause with the given Occur. */ private BooleanClause createBooleanClause(Query query, Occur occur) { if (query instanceof BooleanQuery) { BooleanClause[] clauses = ((BooleanQuery) query).getClauses(); if (clauses.length == 1 && clauses[0].getOccur().equals(Occur.MUST_NOT)) { return clauses[0]; } } return new BooleanClause(query, occur); }
buffer.append(c.getOccur().toString());
if (bc.getOccur() == Occur.SHOULD) { if (m != null) { matches.add(m);
private BooleanQuery rewriteNoScoring() { if (clauseSets.get(Occur.MUST).size() == 0) { return this; } BooleanQuery.Builder newQuery = new BooleanQuery.Builder(); newQuery.setMinimumNumberShouldMatch(getMinimumNumberShouldMatch()); for (BooleanClause clause : clauses) { if (clause.getOccur() == Occur.MUST) { newQuery.add(clause.getQuery(), Occur.FILTER); } else { newQuery.add(clause); } } return newQuery.build(); }
private Query injectOrphans( Query query ) { if ( query instanceof BooleanQuery ) { BooleanQuery source = (BooleanQuery) query; BooleanQuery.Builder builder = new BooleanQuery.Builder(); for ( BooleanClause clause : source.clauses() ) { builder.add( injectOrphans( clause.getQuery() ), clause.getOccur() ); } return builder.build(); } String orphanField = extractTermField( query ); if ( orphanField == null ) { return query; } return new BooleanQuery.Builder() .add( query, Occur.SHOULD ) .add( new TermQuery( new Term( ORPHANS_KEY, orphanField ) ), Occur.SHOULD ) .build(); }
BooleanClause c = clauses.get(0); Query query = c.getQuery(); if (minimumNumberShouldMatch == 1 && c.getOccur() == Occur.SHOULD) { return query; } else if (minimumNumberShouldMatch == 0) { switch (c.getOccur()) { case SHOULD: case MUST: builder.add(rewritten, clause.getOccur()); builder.setMinimumNumberShouldMatch(getMinimumNumberShouldMatch()); for (BooleanClause clause : clauses) { if (clause.getOccur() != Occur.FILTER) { builder.add(clause); if (clause.getOccur() == Occur.SHOULD) { builder.add(new BooleanClause(clause.getQuery(), Occur.MUST)); minShouldMatch--; if (clause.getOccur() != Occur.SHOULD) { builder.add(clause); if (clause.getOccur() != Occur.MUST) { builder.add(clause); switch (clause.getOccur()) { case FILTER: case MUST_NOT:
matchCount++; if (c.getOccur() == Occur.SHOULD) { shouldMatchCount++;
private static void planBooleanQuery(final StringBuilder builder, final BooleanQuery query) { for (final BooleanClause clause : query.clauses()) { builder.append(clause.getOccur()); toPlan(builder, clause.getQuery()); } }
} else { return bq.clauses().stream() .filter(c -> c.getOccur() == Occur.SHOULD) .map(BooleanClause::getQuery) .anyMatch(q -> mightMatchNonNestedDocs(q, nestedPath));
} else { return bq.clauses().stream() .filter(c -> c.getOccur() == Occur.SHOULD) .map(BooleanClause::getQuery) .anyMatch(this::mightMatchNestedDocs);
public static Query applyMinimumShouldMatch(BooleanQuery query, @Nullable String minimumShouldMatch) { if (minimumShouldMatch == null) { return query; } int optionalClauses = 0; for (BooleanClause c : query.clauses()) { if (c.getOccur() == BooleanClause.Occur.SHOULD) { optionalClauses++; } } int msm = calculateMinShouldMatch(optionalClauses, minimumShouldMatch); if (0 < msm) { BooleanQuery.Builder builder = new BooleanQuery.Builder(); for (BooleanClause clause : query) { builder.add(clause); } builder.setMinimumNumberShouldMatch(msm); return builder.build(); } else { return query; } }
@Override public boolean visit(BooleanClause boolClause) { if(boolClause.getOccur() == Occur.MUST_NOT) // skip prohibited, don't fuzzify return false; return true; }
/** * Add a new clause to this {@link Builder}. Note that the order in which * clauses are added does not have any impact on matching documents or query * performance. * @throws TooManyClauses if the new number of clauses exceeds the maximum clause number */ public Builder add(BooleanClause clause) { add(clause.getQuery(), clause.getOccur()); return this; }
protected Query rewriteBoolean(BooleanQuery bq, IndexSearcher searcher) throws RewriteException, IOException { BooleanQuery.Builder newbq = new BooleanQuery.Builder(); newbq.setMinimumNumberShouldMatch(bq.getMinimumNumberShouldMatch()); for (BooleanClause clause : bq) { BooleanClause.Occur occur = clause.getOccur(); if (occur == BooleanClause.Occur.FILTER) occur = BooleanClause.Occur.MUST; // rewrite FILTER to MUST to ensure scoring newbq.add(rewrite(clause.getQuery(), searcher), occur); } return newbq.build(); }