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()); } }
private void getBooleans(BooleanQuery query) { for (BooleanClause clause : query) { if (!clause.isProhibited()) { getTerms(clause.getQuery()); } } }
private void getBooleans(BooleanQuery query) { for (BooleanClause clause : query) { if (!clause.isProhibited()) { getTerms(clause.getQuery()); } } }
/** * Decomposes the provided {@code query} into terms with the exception of {@link PhraseQuery}. Is useful when * determining which terms should not be suggested. {@link PhraseQuery} is exempted because not suggesting some * term which were contained in it is invalid. * @param query query to decompose * @return terms that were in the {@code query} */ public static List<Term> intoTermsExceptPhraseQuery(final Query query) { if (query == null) { return Collections.emptyList(); } List<Term> terms = new LinkedList<>(); LinkedList<Query> queue = new LinkedList<>(); queue.add(query); while (!queue.isEmpty()) { Query q = queue.poll(); if (q instanceof BooleanQuery) { for (BooleanClause bc : ((BooleanQuery) q).clauses()) { queue.add(bc.getQuery()); } } else if (q instanceof TermQuery) { terms.add(((TermQuery) q).getTerm()); } } return terms; }
private boolean needPositionsAndFrequencies(final Query query) { if (query instanceof CustomPhraseQuery) { return true; } if (query instanceof BooleanQuery) { for (BooleanClause bc : ((BooleanQuery) query).clauses()) { if (needPositionsAndFrequencies(bc.getQuery())) { return true; } } } return false; }
/** * Decomposes the provided {@code query} into terms. * @param query query to decompose * @return terms that were in the {@code query} */ public static List<Term> intoTerms(final Query query) { if (query == null) { return Collections.emptyList(); } List<Term> terms = new LinkedList<>(); LinkedList<Query> queue = new LinkedList<>(); queue.add(query); while (!queue.isEmpty()) { Query q = queue.poll(); if (q instanceof BooleanQuery) { for (BooleanClause bc : ((BooleanQuery) q).clauses()) { queue.add(bc.getQuery()); } } else if (q instanceof TermQuery) { terms.add(((TermQuery) q).getTerm()); } else if (q instanceof PhraseQuery) { terms.addAll(Arrays.asList(((PhraseQuery) q).getTerms())); } } return terms; }
BooleanWeight(BooleanQuery query, IndexSearcher searcher, boolean needsScores, float boost) throws IOException { super(query); this.query = query; this.needsScores = needsScores; this.similarity = searcher.getSimilarity(needsScores); weights = new ArrayList<>(); for (BooleanClause c : query) { Weight w = searcher.createWeight(c.getQuery(), needsScores && c.isScoring(), boost); weights.add(w); } }
/** * Builds a new GraphQuery for multi-terms synonyms. * <p> * This is intended for subclasses that wish to customize the generated queries. * @return new Query instance */ protected Query newGraphSynonymQuery(Iterator<Query> queries) { BooleanQuery.Builder builder = new BooleanQuery.Builder(); while (queries.hasNext()) { builder.add(queries.next(), BooleanClause.Occur.SHOULD); } BooleanQuery bq = builder.build(); if (bq.clauses().size() == 1) { return bq.clauses().get(0).getQuery(); } return bq; }
buffer.append(c.getOccur().toString()); Query subQuery = c.getQuery(); if (subQuery instanceof BooleanQuery) { // wrap sub-bools in parens buffer.append("(");
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(); }
Explanation.match(0f, Occur.FILTER + " clause"), e)); } else if (c.isProhibited()) { subs.add(Explanation.noMatch("match on prohibited clause (" + c.getQuery().toString() + ")", e)); fail = true; subs.add(Explanation.noMatch("no match on required clause (" + c.getQuery().toString() + ")", e)); fail = true;
Query query = c.getQuery(); if (minimumNumberShouldMatch == 1 && c.getOccur() == Occur.SHOULD) { return query; boolean actuallyRewritten = false; for (BooleanClause clause : this) { Query query = clause.getQuery(); Query rewritten = query.rewrite(reader); if (rewritten != query) { if (intersection.contains(clause.getQuery())) { if (clause.getOccur() == Occur.SHOULD) { builder.add(new BooleanClause(clause.getQuery(), Occur.MUST)); minShouldMatch--;
@Test void shouldBuildQueryRepresentingArrayProperty() { // given BooleanQuery booleanQuery = (BooleanQuery) newSeekQuery( new Object[]{new Integer[]{1, 2, 3}} ); ConstantScoreQuery constantScoreQuery = (ConstantScoreQuery) booleanQuery.clauses().get( 0 ).getQuery(); TermQuery query = (TermQuery) constantScoreQuery.getQuery(); // then assertEquals( "D1.0|2.0|3.0|", query.getTerm().text() ); }
@Test void shouldBuildQueryRepresentingBoolProperty() { // given BooleanQuery booleanQuery = (BooleanQuery) newSeekQuery( true ); ConstantScoreQuery constantScoreQuery = (ConstantScoreQuery) booleanQuery.clauses().get( 0 ).getQuery(); TermQuery query = (TermQuery) constantScoreQuery.getQuery(); // then assertEquals( "true", query.getTerm().text() ); }
@Test void shouldBuildQueryRepresentingStringProperty() { // given BooleanQuery booleanQuery = (BooleanQuery) newSeekQuery( "Characters" ); ConstantScoreQuery query = (ConstantScoreQuery) booleanQuery.clauses().get( 0 ).getQuery(); // then assertEquals( "Characters", ((TermQuery) query.getQuery()).getTerm().text() ); }
@Test void shouldBuildQueryRepresentingMultipleProperties() { // given BooleanQuery booleanQuery = (BooleanQuery) newSeekQuery( true, "Characters", 12, new Integer[]{1, 2, 3} ); ConstantScoreQuery boolScoreQuery = (ConstantScoreQuery) booleanQuery.clauses().get( 0 ).getQuery(); TermQuery boolTermQuery = (TermQuery) boolScoreQuery.getQuery(); ConstantScoreQuery stringScoreQuery = (ConstantScoreQuery) booleanQuery.clauses().get( 1 ).getQuery(); TermQuery stringTermQuery = (TermQuery) stringScoreQuery.getQuery(); ConstantScoreQuery numberScoreQuery = (ConstantScoreQuery) booleanQuery.clauses().get( 2 ).getQuery(); NumericRangeQuery<Double> numericRangeQuery = (NumericRangeQuery<Double>) numberScoreQuery.getQuery(); ConstantScoreQuery arrayScoreQuery = (ConstantScoreQuery) booleanQuery.clauses().get( 3 ).getQuery(); TermQuery arrayTermQuery = (TermQuery) arrayScoreQuery.getQuery(); // then assertEquals( "true", boolTermQuery.getTerm().text() ); assertEquals( "Characters", stringTermQuery.getTerm().text() ); assertEquals( 12.0, numericRangeQuery.getMin(), 0.001 ); assertEquals( 12.0, numericRangeQuery.getMax(), 0.001 ); assertEquals( "D1.0|2.0|3.0|", arrayTermQuery.getTerm().text() ); }
@SuppressWarnings( "unchecked" ) @Test void shouldBuildQueryRepresentingNumberProperty() { // given BooleanQuery booleanQuery = (BooleanQuery) newSeekQuery( 12 ); ConstantScoreQuery constantScoreQuery = (ConstantScoreQuery) booleanQuery.clauses().get( 0 ).getQuery(); NumericRangeQuery<Double> query = (NumericRangeQuery<Double>) constantScoreQuery.getQuery(); // then assertEquals( 12.0, query.getMin(), 0.001 ); assertEquals( 12.0, query.getMax(),0.001 ); }
private Query boolToExtendedCommonTermsQuery(BooleanQuery bq, Occur highFreqOccur, Occur lowFreqOccur, float maxTermFrequency, MappedFieldType fieldType) { ExtendedCommonTermsQuery query = new ExtendedCommonTermsQuery(highFreqOccur, lowFreqOccur, maxTermFrequency, fieldType); for (BooleanClause clause : bq.clauses()) { if (!(clause.getQuery() instanceof TermQuery)) { return bq; } query.add(((TermQuery) clause.getQuery()).getTerm()); } return query; } }
private static void planBooleanQuery(final StringBuilder builder, final BooleanQuery query) { for (final BooleanClause clause : query.clauses()) { builder.append(clause.getOccur()); toPlan(builder, clause.getQuery()); } }