Apache/lucene
1
0
Fork 0
mirror of https://github.com/apache/lucene.git synced 2025-03-06 16:29:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

Convert BooleanClause class to record class (#13261)

Browse Source
This commit is contained in:
Pulkit Gupta 2024-04-04 21:21:48 +05:30 committed by GitHub
parent a2676b1b26
commit 2ee537ce16
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
28 changed files with 95 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lucene/CHANGES.txt
View File

@ -94,6 +94,8 @@ API Changes
* GITHUB#13242: Replace `IOContext.READ` with `IOContext.DEFAULT`. (Adrien Grand) * GITHUB#13242: Replace `IOContext.READ` with `IOContext.DEFAULT`. (Adrien Grand)
* GITHUB#13261: Convert `BooleanClause` class to record class. (Pulkit Gupta)
New Features New Features
--------------------- ---------------------

1
lucene/MIGRATE.md
View File

@ -179,6 +179,7 @@ record's fields are only available with accessor methods. Some code may need to
access the members using method calls instead of field accesses. Affected classes: access the members using method calls instead of field accesses. Affected classes:
- `IOContext`, `MergeInfo`, and `FlushInfo` (GITHUB#13205) - `IOContext`, `MergeInfo`, and `FlushInfo` (GITHUB#13205)
- `BooleanClause` (GITHUB#13261)
### Boolean flags on IOContext replaced with a new ReadAdvice enum. ### Boolean flags on IOContext replaced with a new ReadAdvice enum.

40
lucene/core/src/java/org/apache/lucene/search/BooleanClause.java
View File

@ -19,7 +19,7 @@ package org.apache.lucene.search;
import java.util.Objects; import java.util.Objects;
/** A clause in a BooleanQuery. */ /** A clause in a BooleanQuery. */
public final class BooleanClause { public record BooleanClause(Query query, Occur occur) {
/** Specifies how clauses are to occur in matching documents. */ /** Specifies how clauses are to occur in matching documents. */
public enum Occur { public enum Occur {
@ -67,23 +67,10 @@ public final class BooleanClause {
}; };
} }
/** The query whose matching documents are combined by the boolean query. */
private final Query query;
private final Occur occur;
/** Constructs a BooleanClause. */ /** Constructs a BooleanClause. */
public BooleanClause(Query query, Occur occur) { public BooleanClause {
this.query = Objects.requireNonNull(query, "Query must not be null"); Objects.requireNonNull(query, "Query must not be null");
this.occur = Objects.requireNonNull(occur, "Occur must not be null"); Objects.requireNonNull(occur, "Occur must not be null");
}
public Occur getOccur() {
return occur;
}
public Query getQuery() {
return query;
} }
public boolean isProhibited() { public boolean isProhibited() {
@ -97,23 +84,4 @@ public final class BooleanClause {
public boolean isScoring() { public boolean isScoring() {
return occur == Occur.MUST || occur == Occur.SHOULD; return occur == Occur.MUST || occur == Occur.SHOULD;
} }
/** Returns true if <code>o</code> is equal to this. */
@Override
public boolean equals(Object o) {
if (o == null || !(o instanceof BooleanClause)) return false;
BooleanClause other = (BooleanClause) o;
return this.query.equals(other.query) && this.occur == other.occur;
}
/** Returns a hash code value for this object. */
@Override
public int hashCode() {
return 31 * query.hashCode() + occur.hashCode();
}
@Override
public String toString() {
return occur.toString() + query.toString();
}
} }

48
lucene/core/src/java/org/apache/lucene/search/BooleanQuery.java
View File

@ -153,7 +153,7 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
clauseSets.put(Occur.FILTER, new HashSet<>()); clauseSets.put(Occur.FILTER, new HashSet<>());
clauseSets.put(Occur.MUST_NOT, new HashSet<>()); clauseSets.put(Occur.MUST_NOT, new HashSet<>());
for (BooleanClause clause : clauses) { for (BooleanClause clause : clauses) {
clauseSets.get(clause.getOccur()).add(clause.getQuery()); clauseSets.get(clause.occur()).add(clause.query());
} }
} }
@ -184,8 +184,8 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
boolean isTwoClausePureDisjunctionWithTerms() { boolean isTwoClausePureDisjunctionWithTerms() {
return clauses.size() == 2 return clauses.size() == 2
&& isPureDisjunction() && isPureDisjunction()
&& clauses.get(0).getQuery() instanceof TermQuery && clauses.get(0).query() instanceof TermQuery
&& clauses.get(1).getQuery() instanceof TermQuery; && clauses.get(1).query() instanceof TermQuery;
} }
/** /**
@ -197,7 +197,7 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
BooleanQuery.Builder newQuery = new BooleanQuery.Builder(); BooleanQuery.Builder newQuery = new BooleanQuery.Builder();
Query[] queries = new Query[3]; Query[] queries = new Query[3];
for (int i = 0; i < clauses.size(); i++) { for (int i = 0; i < clauses.size(); i++) {
TermQuery termQuery = (TermQuery) clauses.get(i).getQuery(); TermQuery termQuery = (TermQuery) clauses.get(i).query();
// Optimization will count term query several times so use cache to avoid multiple terms // Optimization will count term query several times so use cache to avoid multiple terms
// dictionary lookups // dictionary lookups
if (termQuery.getTermStates() == null) { if (termQuery.getTermStates() == null) {
@ -235,7 +235,7 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
|| (clauseSets.get(Occur.MUST).size() + clauseSets.get(Occur.FILTER).size() == 0); || (clauseSets.get(Occur.MUST).size() + clauseSets.get(Occur.FILTER).size() == 0);
for (BooleanClause clause : clauses) { for (BooleanClause clause : clauses) {
Query query = clause.getQuery(); Query query = clause.query();
// NOTE: rewritingNoScoring() should not call rewrite(), otherwise this // NOTE: rewritingNoScoring() should not call rewrite(), otherwise this
// method could run in exponential time with the depth of the query as // method could run in exponential time with the depth of the query as
// every new level would rewrite 2x more than its parent level. // every new level would rewrite 2x more than its parent level.
@ -249,7 +249,7 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
if (rewritten instanceof BooleanQuery) { if (rewritten instanceof BooleanQuery) {
rewritten = ((BooleanQuery) rewritten).rewriteNoScoring(); rewritten = ((BooleanQuery) rewritten).rewriteNoScoring();
} }
BooleanClause.Occur occur = clause.getOccur(); BooleanClause.Occur occur = clause.occur();
if (occur == Occur.SHOULD && keepShould == false) { if (occur == Occur.SHOULD && keepShould == false) {
// ignore clause // ignore clause
actuallyRewritten = true; actuallyRewritten = true;
@ -287,11 +287,11 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
// optimize 1-clause queries // optimize 1-clause queries
if (clauses.size() == 1) { if (clauses.size() == 1) {
BooleanClause c = clauses.get(0); BooleanClause c = clauses.get(0);
Query query = c.getQuery(); Query query = c.query();
if (minimumNumberShouldMatch == 1 && c.getOccur() == Occur.SHOULD) { if (minimumNumberShouldMatch == 1 && c.occur() == Occur.SHOULD) {
return query; return query;
} else if (minimumNumberShouldMatch == 0) { } else if (minimumNumberShouldMatch == 0) {
switch (c.getOccur()) { switch (c.occur()) {
case SHOULD: case SHOULD:
case MUST: case MUST:
return query; return query;
@ -313,8 +313,8 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
builder.setMinimumNumberShouldMatch(getMinimumNumberShouldMatch()); builder.setMinimumNumberShouldMatch(getMinimumNumberShouldMatch());
boolean actuallyRewritten = false; boolean actuallyRewritten = false;
for (BooleanClause clause : this) { for (BooleanClause clause : this) {
Query query = clause.getQuery(); Query query = clause.query();
BooleanClause.Occur occur = clause.getOccur(); BooleanClause.Occur occur = clause.occur();
Query rewritten; Query rewritten;
if (occur == Occur.FILTER || occur == Occur.MUST_NOT) { if (occur == Occur.FILTER || occur == Occur.MUST_NOT) {
// Clauses that are not involved in scoring can get some extra simplifications // Clauses that are not involved in scoring can get some extra simplifications
@ -396,7 +396,7 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
BooleanQuery.Builder builder = new BooleanQuery.Builder(); BooleanQuery.Builder builder = new BooleanQuery.Builder();
builder.setMinimumNumberShouldMatch(getMinimumNumberShouldMatch()); builder.setMinimumNumberShouldMatch(getMinimumNumberShouldMatch());
for (BooleanClause clause : clauses) { for (BooleanClause clause : clauses) {
if (clause.getOccur() != Occur.FILTER) { if (clause.occur() != Occur.FILTER) {
builder.add(clause); builder.add(clause);
} }
} }
@ -420,9 +420,9 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
int minShouldMatch = getMinimumNumberShouldMatch(); int minShouldMatch = getMinimumNumberShouldMatch();
for (BooleanClause clause : clauses) { for (BooleanClause clause : clauses) {
if (intersection.contains(clause.getQuery())) { if (intersection.contains(clause.query())) {
if (clause.getOccur() == Occur.SHOULD) { if (clause.occur() == Occur.SHOULD) {
builder.add(new BooleanClause(clause.getQuery(), Occur.MUST)); builder.add(new BooleanClause(clause.query(), Occur.MUST));
minShouldMatch--; minShouldMatch--;
} }
} else { } else {
@ -459,7 +459,7 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
builder.add(query, Occur.SHOULD); builder.add(query, Occur.SHOULD);
} }
for (BooleanClause clause : clauses) { for (BooleanClause clause : clauses) {
if (clause.getOccur() != Occur.SHOULD) { if (clause.occur() != Occur.SHOULD) {
builder.add(clause); builder.add(clause);
} }
} }
@ -491,7 +491,7 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
builder.add(query, Occur.MUST); builder.add(query, Occur.MUST);
} }
for (BooleanClause clause : clauses) { for (BooleanClause clause : clauses) {
if (clause.getOccur() != Occur.MUST) { if (clause.occur() != Occur.MUST) {
builder.add(clause); builder.add(clause);
} }
} }
@ -517,7 +517,7 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
// ignore SHOULD clause for now // ignore SHOULD clause for now
BooleanQuery.Builder builder = new BooleanQuery.Builder(); BooleanQuery.Builder builder = new BooleanQuery.Builder();
for (BooleanClause clause : clauses) { for (BooleanClause clause : clauses) {
switch (clause.getOccur()) { switch (clause.occur()) {
case FILTER: case FILTER:
case MUST_NOT: case MUST_NOT:
builder.add(clause); builder.add(clause);
@ -555,8 +555,8 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
builder.setMinimumNumberShouldMatch(minimumNumberShouldMatch); builder.setMinimumNumberShouldMatch(minimumNumberShouldMatch);
boolean actuallyRewritten = false; boolean actuallyRewritten = false;
for (BooleanClause clause : clauses) { for (BooleanClause clause : clauses) {
if (clause.getOccur() == Occur.SHOULD && clause.getQuery() instanceof BooleanQuery) { if (clause.occur() == Occur.SHOULD && clause.query() instanceof BooleanQuery) {
BooleanQuery innerQuery = (BooleanQuery) clause.getQuery(); BooleanQuery innerQuery = (BooleanQuery) clause.query();
if (innerQuery.isPureDisjunction()) { if (innerQuery.isPureDisjunction()) {
actuallyRewritten = true; actuallyRewritten = true;
for (BooleanClause innerClause : innerQuery.clauses()) { for (BooleanClause innerClause : innerQuery.clauses()) {
@ -586,8 +586,8 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
if (shoulds.size() == minimumNumberShouldMatch) { if (shoulds.size() == minimumNumberShouldMatch) {
BooleanQuery.Builder builder = new BooleanQuery.Builder(); BooleanQuery.Builder builder = new BooleanQuery.Builder();
for (BooleanClause clause : clauses) { for (BooleanClause clause : clauses) {
if (clause.getOccur() == Occur.SHOULD) { if (clause.occur() == Occur.SHOULD) {
builder.add(clause.getQuery(), Occur.MUST); builder.add(clause.query(), Occur.MUST);
} else { } else {
builder.add(clause); builder.add(clause);
} }
@ -631,9 +631,9 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
int i = 0; int i = 0;
for (BooleanClause c : this) { for (BooleanClause c : this) {
buffer.append(c.getOccur().toString()); buffer.append(c.occur().toString());
Query subQuery = c.getQuery(); Query subQuery = c.query();
if (subQuery instanceof BooleanQuery) { // wrap sub-bools in parens if (subQuery instanceof BooleanQuery) { // wrap sub-bools in parens
buffer.append("("); buffer.append("(");
buffer.append(subQuery.toString(field)); buffer.append(subQuery.toString(field));

20
lucene/core/src/java/org/apache/lucene/search/BooleanWeight.java
View File

@ -59,7 +59,7 @@ final class BooleanWeight extends Weight {
for (BooleanClause c : query) { for (BooleanClause c : query) {
Weight w = Weight w =
searcher.createWeight( searcher.createWeight(
c.getQuery(), c.isScoring() ? scoreMode : ScoreMode.COMPLETE_NO_SCORES, boost); c.query(), c.isScoring() ? scoreMode : ScoreMode.COMPLETE_NO_SCORES, boost);
weightedClauses.add(new WeightedBooleanClause(c, w)); weightedClauses.add(new WeightedBooleanClause(c, w));
} }
} }
@ -87,20 +87,18 @@ final class BooleanWeight extends Weight {
e)); e));
} else if (c.isProhibited()) { } else if (c.isProhibited()) {
subs.add( subs.add(
Explanation.noMatch( Explanation.noMatch("match on prohibited clause (" + c.query().toString() + ")", e));
"match on prohibited clause (" + c.getQuery().toString() + ")", e));
fail = true; fail = true;
} }
if (!c.isProhibited()) { if (!c.isProhibited()) {
matchCount++; matchCount++;
} }
if (c.getOccur() == Occur.SHOULD) { if (c.occur() == Occur.SHOULD) {
shouldMatchCount++; shouldMatchCount++;
} }
} else if (c.isRequired()) { } else if (c.isRequired()) {
subs.add( subs.add(
Explanation.noMatch( Explanation.noMatch("no match on required clause (" + c.query().toString() + ")", e));
"no match on required clause (" + c.getQuery().toString() + ")", e));
fail = true; fail = true;
} }
} }
@ -145,7 +143,7 @@ final class BooleanWeight extends Weight {
} }
matches.add(m); matches.add(m);
} }
if (bc.getOccur() == Occur.SHOULD) { if (bc.occur() == Occur.SHOULD) {
if (m != null) { if (m != null) {
matches.add(m); matches.add(m);
shouldMatchCount++; shouldMatchCount++;
@ -202,7 +200,7 @@ final class BooleanWeight extends Weight {
for (WeightedBooleanClause wc : weightedClauses) { for (WeightedBooleanClause wc : weightedClauses) {
Weight w = wc.weight; Weight w = wc.weight;
BooleanClause c = wc.clause; BooleanClause c = wc.clause;
if (c.getOccur() != Occur.SHOULD) { if (c.occur() != Occur.SHOULD) {
continue; continue;
} }
ScorerSupplier scorer = w.scorerSupplier(context); ScorerSupplier scorer = w.scorerSupplier(context);
@ -227,7 +225,7 @@ final class BooleanWeight extends Weight {
for (WeightedBooleanClause wc : weightedClauses) { for (WeightedBooleanClause wc : weightedClauses) {
Weight w = wc.weight; Weight w = wc.weight;
BooleanClause c = wc.clause; BooleanClause c = wc.clause;
if (c.getOccur() != Occur.SHOULD) { if (c.occur() != Occur.SHOULD) {
continue; continue;
} }
BulkScorer subScorer = w.bulkScorer(context); BulkScorer subScorer = w.bulkScorer(context);
@ -525,7 +523,7 @@ final class BooleanWeight extends Weight {
int optCount = 0; int optCount = 0;
boolean unknownCount = false; boolean unknownCount = false;
for (WeightedBooleanClause weightedClause : weightedClauses) { for (WeightedBooleanClause weightedClause : weightedClauses) {
if (weightedClause.clause.getOccur() != occur) { if (weightedClause.clause.occur() != occur) {
continue; continue;
} }
int count = weightedClause.weight.count(context); int count = weightedClause.weight.count(context);
@ -598,7 +596,7 @@ final class BooleanWeight extends Weight {
return null; return null;
} }
} else { } else {
scorers.get(c.getOccur()).add(subScorer); scorers.get(c.occur()).add(subScorer);
} }
} }

5
lucene/core/src/java/org/apache/lucene/search/IndriAndWeight.java
View File

@ -39,7 +39,7 @@ public class IndriAndWeight extends Weight {
this.scoreMode = scoreMode; this.scoreMode = scoreMode;
weights = new ArrayList<>(); weights = new ArrayList<>();
for (BooleanClause c : query) { for (BooleanClause c : query) {
Weight w = searcher.createWeight(c.getQuery(), scoreMode, 1.0f); Weight w = searcher.createWeight(c.query(), scoreMode, 1.0f);
weights.add(w); weights.add(w);
} }
} }
@ -100,8 +100,7 @@ public class IndriAndWeight extends Weight {
subs.add(e); subs.add(e);
} else if (c.isRequired()) { } else if (c.isRequired()) {
subs.add( subs.add(
Explanation.noMatch( Explanation.noMatch("no match on required clause (" + c.query().toString() + ")", e));
"no match on required clause (" + c.getQuery().toString() + ")", e));
fail = true; fail = true;
} }
} }

4
lucene/core/src/java/org/apache/lucene/search/IndriQuery.java
View File

@ -43,9 +43,9 @@ public abstract class IndriQuery extends Query implements Iterable<BooleanClause
int i = 0; int i = 0;
for (BooleanClause c : this) { for (BooleanClause c : this) {
buffer.append(c.getOccur().toString()); buffer.append(c.occur().toString());
Query subQuery = c.getQuery(); Query subQuery = c.query();
if (subQuery instanceof BooleanQuery) { // wrap sub-bools in parens if (subQuery instanceof BooleanQuery) { // wrap sub-bools in parens
buffer.append("("); buffer.append("(");
buffer.append(subQuery.toString(field)); buffer.append(subQuery.toString(field));

2
lucene/core/src/java/org/apache/lucene/util/QueryBuilder.java
View File

@ -624,7 +624,7 @@ public class QueryBuilder {
} }
BooleanQuery bq = builder.build(); BooleanQuery bq = builder.build();
if (bq.clauses().size() == 1) { if (bq.clauses().size() == 1) {
return bq.clauses().get(0).getQuery(); return bq.clauses().get(0).query();
} }
return bq; return bq;
} }

2
lucene/core/src/test/org/apache/lucene/search/TestBooleanMinShouldMatch.java
View File

@ -320,7 +320,7 @@ public class TestBooleanMinShouldMatch extends LuceneTestCase {
public void postCreate(BooleanQuery.Builder q) { public void postCreate(BooleanQuery.Builder q) {
int opt = 0; int opt = 0;
for (BooleanClause clause : q.build().clauses()) { for (BooleanClause clause : q.build().clauses()) {
if (clause.getOccur() == BooleanClause.Occur.SHOULD) opt++; if (clause.occur() == BooleanClause.Occur.SHOULD) opt++;
} }
q.setMinimumNumberShouldMatch(random().nextInt(opt + 2)); q.setMinimumNumberShouldMatch(random().nextInt(opt + 2));
if (random().nextBoolean()) { if (random().nextBoolean()) {

2
lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java
View File

@ -474,7 +474,7 @@ public class TestBooleanQuery extends LuceneTestCase {
throws IOException { throws IOException {
final BooleanQuery.Builder bq2Builder = new BooleanQuery.Builder(); final BooleanQuery.Builder bq2Builder = new BooleanQuery.Builder();
for (BooleanClause c : bq) { for (BooleanClause c : bq) {
if (c.getOccur() != Occur.FILTER) { if (c.occur() != Occur.FILTER) {
bq2Builder.add(c); bq2Builder.add(c);
} }
} }

2
lucene/core/src/test/org/apache/lucene/search/TestMinShouldMatch2.java
View File

@ -360,7 +360,7 @@ public class TestMinShouldMatch2 extends LuceneTestCase {
for (BooleanClause clause : bq.clauses()) { for (BooleanClause clause : bq.clauses()) {
assert !clause.isProhibited(); assert !clause.isProhibited();
assert !clause.isRequired(); assert !clause.isRequired();
Term term = ((TermQuery) clause.getQuery()).getTerm(); Term term = ((TermQuery) clause.query()).getTerm();
long ord = dv.lookupTerm(term.bytes()); long ord = dv.lookupTerm(term.bytes());
if (ord >= 0) { if (ord >= 0) {
boolean success = ords.add(ord); boolean success = ords.add(ord);

4
lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java
View File

@ -111,7 +111,7 @@ public class TestMultiTermQueryRewrites extends LuceneTestCase {
final BooleanQuery bq = (BooleanQuery) q; final BooleanQuery bq = (BooleanQuery) q;
Term last = null, act; Term last = null, act;
for (BooleanClause clause : bq.clauses()) { for (BooleanClause clause : bq.clauses()) {
act = extractTerm(clause.getQuery()); act = extractTerm(clause.query());
if (last != null) { if (last != null) {
assertTrue("sort order of terms in BQ violated", last.compareTo(act) < 0); assertTrue("sort order of terms in BQ violated", last.compareTo(act) < 0);
} }
@ -150,7 +150,7 @@ public class TestMultiTermQueryRewrites extends LuceneTestCase {
private void checkBooleanQueryBoosts(BooleanQuery bq) { private void checkBooleanQueryBoosts(BooleanQuery bq) {
for (BooleanClause clause : bq.clauses()) { for (BooleanClause clause : bq.clauses()) {
final BoostQuery boostQ = (BoostQuery) clause.getQuery(); final BoostQuery boostQ = (BoostQuery) clause.query();
final TermQuery mtq = (TermQuery) boostQ.getQuery(); final TermQuery mtq = (TermQuery) boostQ.getQuery();
assertEquals( assertEquals(
"Parallel sorting of boosts in rewrite mode broken", "Parallel sorting of boosts in rewrite mode broken",

4
lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java
View File

@ -150,8 +150,8 @@ public class TestTermRangeQuery extends LuceneTestCase {
final Set<String> allowedTerms = asSet(terms); final Set<String> allowedTerms = asSet(terms);
assertEquals(allowedTerms.size(), bq.clauses().size()); assertEquals(allowedTerms.size(), bq.clauses().size());
for (BooleanClause c : bq.clauses()) { for (BooleanClause c : bq.clauses()) {
assertTrue(c.getQuery() instanceof TermQuery); assertTrue(c.query() instanceof TermQuery);
final TermQuery tq = (TermQuery) c.getQuery(); final TermQuery tq = (TermQuery) c.query();
final String term = tq.getTerm().text(); final String term = tq.getTerm().text();
assertTrue("invalid term: " + term, allowedTerms.contains(term)); assertTrue("invalid term: " + term, allowedTerms.contains(term));
allowedTerms.remove(term); // remove to fail on double terms allowedTerms.remove(term); // remove to fail on double terms

2
lucene/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java
View File

@ -133,7 +133,7 @@ public class WeightedSpanTermExtractor {
} else if (query instanceof BooleanQuery) { } else if (query instanceof BooleanQuery) {
for (BooleanClause clause : (BooleanQuery) query) { for (BooleanClause clause : (BooleanQuery) query) {
if (!clause.isProhibited()) { if (!clause.isProhibited()) {
extract(clause.getQuery(), boost, terms); extract(clause.query(), boost, terms);
} }
} }
} else if (query instanceof PhraseQuery) { } else if (query instanceof PhraseQuery) {

4
lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/FieldQuery.java
View File

@ -114,7 +114,7 @@ public class FieldQuery {
BooleanQuery bq = (BooleanQuery) sourceQuery; BooleanQuery bq = (BooleanQuery) sourceQuery;
for (BooleanClause clause : bq) { for (BooleanClause clause : bq) {
if (!clause.isProhibited()) { if (!clause.isProhibited()) {
flatten(clause.getQuery(), searcher, flatQueries, boost); flatten(clause.query(), searcher, flatQueries, boost);
} }
} }
} else if (sourceQuery instanceof DisjunctionMaxQuery) { } else if (sourceQuery instanceof DisjunctionMaxQuery) {
@ -330,7 +330,7 @@ public class FieldQuery {
} else if (query instanceof MultiTermQuery && searcher != null) { } else if (query instanceof MultiTermQuery && searcher != null) {
BooleanQuery mtqTerms = (BooleanQuery) query.rewrite(searcher); BooleanQuery mtqTerms = (BooleanQuery) query.rewrite(searcher);
for (BooleanClause clause : mtqTerms) { for (BooleanClause clause : mtqTerms) {
termSet.add(((TermQuery) clause.getQuery()).getTerm().text()); termSet.add(((TermQuery) clause.query()).getTerm().text());
} }
} else } else
throw new RuntimeException("query \"" + query.toString() + "\" must be flatten first."); throw new RuntimeException("query \"" + query.toString() + "\" must be flatten first.");

8
lucene/monitor/src/java/org/apache/lucene/monitor/QueryAnalyzer.java
View File

@ -84,9 +84,7 @@ class QueryAnalyzer {
if (parent instanceof BooleanQuery) { if (parent instanceof BooleanQuery) {
BooleanQuery bq = (BooleanQuery) parent; BooleanQuery bq = (BooleanQuery) parent;
long positiveCount = long positiveCount =
bq.clauses().stream() bq.clauses().stream().filter(c -> c.occur() != BooleanClause.Occur.MUST_NOT).count();
.filter(c -> c.getOccur() != BooleanClause.Occur.MUST_NOT)
.count();
if (positiveCount == 0) { if (positiveCount == 0) {
children.add(w -> QueryTree.anyTerm("PURE NEGATIVE QUERY[" + parent + "]")); children.add(w -> QueryTree.anyTerm("PURE NEGATIVE QUERY[" + parent + "]"));
} }
@ -101,8 +99,8 @@ class QueryAnalyzer {
bq.clauses().stream() bq.clauses().stream()
.filter( .filter(
c -> c ->
c.getOccur() == BooleanClause.Occur.MUST c.occur() == BooleanClause.Occur.MUST
|| c.getOccur() == BooleanClause.Occur.FILTER) || c.occur() == BooleanClause.Occur.FILTER)
.count(); .count();
if (requiredCount > 0) { if (requiredCount > 0) {
return QueryVisitor.EMPTY_VISITOR; return QueryVisitor.EMPTY_VISITOR;

8
lucene/monitor/src/java/org/apache/lucene/monitor/QueryDecomposer.java
View File

@ -82,11 +82,11 @@ public class QueryDecomposer {
Set<Query> mandatory = new HashSet<>(); Set<Query> mandatory = new HashSet<>();
for (BooleanClause clause : q) { for (BooleanClause clause : q) {
if (clause.getOccur() == BooleanClause.Occur.MUST if (clause.occur() == BooleanClause.Occur.MUST
|| clause.getOccur() == BooleanClause.Occur.FILTER) mandatory.add(clause.getQuery()); || clause.occur() == BooleanClause.Occur.FILTER) mandatory.add(clause.query());
else if (clause.getOccur() == BooleanClause.Occur.MUST_NOT) exclusions.add(clause.getQuery()); else if (clause.occur() == BooleanClause.Occur.MUST_NOT) exclusions.add(clause.query());
else { else {
subqueries.addAll(decompose(clause.getQuery())); subqueries.addAll(decompose(clause.query()));
} }
} }

4
lucene/monitor/src/test/org/apache/lucene/monitor/TestBooleanTermExtractor.java
View File

@ -81,8 +81,8 @@ public class TestBooleanTermExtractor extends LuceneTestCase {
Query q = MonitorTestBase.parse("+*:*"); Query q = MonitorTestBase.parse("+*:*");
assertTrue(q instanceof BooleanQuery); assertTrue(q instanceof BooleanQuery);
BooleanClause clause = ((BooleanQuery) q).iterator().next(); BooleanClause clause = ((BooleanQuery) q).iterator().next();
assertTrue(clause.getQuery() instanceof MatchAllDocsQuery); assertTrue(clause.query() instanceof MatchAllDocsQuery);
assertEquals(BooleanClause.Occur.MUST, clause.getOccur()); assertEquals(BooleanClause.Occur.MUST, clause.occur());
Set<Term> terms = collectTerms(q); Set<Term> terms = collectTerms(q);
assertEquals(1, terms.size()); assertEquals(1, terms.size());

28
lucene/queries/src/test/org/apache/lucene/queries/mlt/TestMoreLikeThis.java
View File

@ -166,18 +166,18 @@ public class TestMoreLikeThis extends LuceneTestCase {
List<BooleanClause> clauses = query.clauses(); List<BooleanClause> clauses = query.clauses();
assertTrue(clauses.size() == 2); assertTrue(clauses.size() == 2);
Term term = ((TermQuery) clauses.get(0).getQuery()).getTerm(); Term term = ((TermQuery) clauses.get(0).query()).getTerm();
assertTrue(term.text().equals("all")); assertTrue(term.text().equals("all"));
term = ((TermQuery) clauses.get(1).getQuery()).getTerm(); term = ((TermQuery) clauses.get(1).query()).getTerm();
assertTrue(term.text().equals("tenth")); assertTrue(term.text().equals("tenth"));
query = (BooleanQuery) mlt.like("one_percent", new StringReader("tenth all all")); query = (BooleanQuery) mlt.like("one_percent", new StringReader("tenth all all"));
clauses = query.clauses(); clauses = query.clauses();
assertTrue(clauses.size() == 2); assertTrue(clauses.size() == 2);
term = ((TermQuery) clauses.get(0).getQuery()).getTerm(); term = ((TermQuery) clauses.get(0).query()).getTerm();
assertTrue(term.text().equals("all")); assertTrue(term.text().equals("all"));
term = ((TermQuery) clauses.get(1).getQuery()).getTerm(); term = ((TermQuery) clauses.get(1).query()).getTerm();
assertTrue(term.text().equals("tenth")); assertTrue(term.text().equals("tenth"));
// clean up // clean up
@ -203,7 +203,7 @@ public class TestMoreLikeThis extends LuceneTestCase {
"Expected " + originalValues.size() + " clauses.", originalValues.size(), clauses.size()); "Expected " + originalValues.size() + " clauses.", originalValues.size(), clauses.size());
for (BooleanClause clause : clauses) { for (BooleanClause clause : clauses) {
BoostQuery bq = (BoostQuery) clause.getQuery(); BoostQuery bq = (BoostQuery) clause.query();
TermQuery tq = (TermQuery) bq.getQuery(); TermQuery tq = (TermQuery) bq.getQuery();
Float termBoost = originalValues.get(tq.getTerm().text()); Float termBoost = originalValues.get(tq.getTerm().text());
assertNotNull("Expected term " + tq.getTerm().text(), termBoost); assertNotNull("Expected term " + tq.getTerm().text(), termBoost);
@ -230,7 +230,7 @@ public class TestMoreLikeThis extends LuceneTestCase {
Collection<BooleanClause> clauses = query.clauses(); Collection<BooleanClause> clauses = query.clauses();
for (BooleanClause clause : clauses) { for (BooleanClause clause : clauses) {
BoostQuery bq = (BoostQuery) clause.getQuery(); BoostQuery bq = (BoostQuery) clause.query();
TermQuery tq = (TermQuery) bq.getQuery(); TermQuery tq = (TermQuery) bq.getQuery();
originalValues.put(tq.getTerm().text(), bq.getBoost()); originalValues.put(tq.getTerm().text(), bq.getBoost());
} }
@ -260,7 +260,7 @@ public class TestMoreLikeThis extends LuceneTestCase {
Collection<BooleanClause> clauses = query.clauses(); Collection<BooleanClause> clauses = query.clauses();
assertEquals("Expected 2 clauses only!", 2, clauses.size()); assertEquals("Expected 2 clauses only!", 2, clauses.size());
for (BooleanClause clause : clauses) { for (BooleanClause clause : clauses) {
Term term = ((TermQuery) clause.getQuery()).getTerm(); Term term = ((TermQuery) clause.query()).getTerm();
assertTrue( assertTrue(
Arrays.asList(new Term("text", "lucene"), new Term("text", "apache")).contains(term)); Arrays.asList(new Term("text", "lucene"), new Term("text", "apache")).contains(term));
} }
@ -284,7 +284,7 @@ public class TestMoreLikeThis extends LuceneTestCase {
Collection<BooleanClause> clauses = query.clauses(); Collection<BooleanClause> clauses = query.clauses();
assertEquals("Expected 1 clauses only!", 1, clauses.size()); assertEquals("Expected 1 clauses only!", 1, clauses.size());
for (BooleanClause clause : clauses) { for (BooleanClause clause : clauses) {
Term term = ((TermQuery) clause.getQuery()).getTerm(); Term term = ((TermQuery) clause.query()).getTerm();
assertEquals(new Term(mltField1, "lucene"), term); assertEquals(new Term(mltField1, "lucene"), term);
} }
analyzer.close(); analyzer.close();
@ -319,7 +319,7 @@ public class TestMoreLikeThis extends LuceneTestCase {
// None of the Not Expected terms is in the query // None of the Not Expected terms is in the query
for (BooleanClause clause : clauses) { for (BooleanClause clause : clauses) {
Term term = ((TermQuery) clause.getQuery()).getTerm(); Term term = ((TermQuery) clause.query()).getTerm();
assertFalse( assertFalse(
"Unexpected term '" + term + "' found in query terms", unexpectedTerms.contains(term)); "Unexpected term '" + term + "' found in query terms", unexpectedTerms.contains(term));
} }
@ -358,7 +358,7 @@ public class TestMoreLikeThis extends LuceneTestCase {
Collection<BooleanClause> clauses = query.clauses(); Collection<BooleanClause> clauses = query.clauses();
HashSet<Term> clausesTerms = new HashSet<>(); HashSet<Term> clausesTerms = new HashSet<>();
for (BooleanClause clause : clauses) { for (BooleanClause clause : clauses) {
Term term = ((TermQuery) clause.getQuery()).getTerm(); Term term = ((TermQuery) clause.query()).getTerm();
clausesTerms.add(term); clausesTerms.add(term);
} }
@ -366,7 +366,7 @@ public class TestMoreLikeThis extends LuceneTestCase {
// None of the Not Expected terms is in the query // None of the Not Expected terms is in the query
for (BooleanClause clause : clauses) { for (BooleanClause clause : clauses) {
Term term = ((TermQuery) clause.getQuery()).getTerm(); Term term = ((TermQuery) clause.query()).getTerm();
assertFalse( assertFalse(
"Unexpected term '" + term + "' found in query terms", unexpectedTerms.contains(term)); "Unexpected term '" + term + "' found in query terms", unexpectedTerms.contains(term));
} }
@ -422,7 +422,7 @@ public class TestMoreLikeThis extends LuceneTestCase {
expectedTerms[idx++] = new Term("text", text); expectedTerms[idx++] = new Term("text", text);
} }
for (BooleanClause clause : clauses) { for (BooleanClause clause : clauses) {
Term term = ((TermQuery) clause.getQuery()).getTerm(); Term term = ((TermQuery) clause.query()).getTerm();
assertTrue(Arrays.asList(expectedTerms).contains(term)); assertTrue(Arrays.asList(expectedTerms).contains(term));
} }
@ -587,7 +587,7 @@ public class TestMoreLikeThis extends LuceneTestCase {
final double boost10 = final double boost10 =
((BooleanQuery) mlt.like("text", new StringReader("lucene|10 release|1"))) ((BooleanQuery) mlt.like("text", new StringReader("lucene|10 release|1")))
.clauses().stream() .clauses().stream()
.map(BooleanClause::getQuery) .map(BooleanClause::query)
.map(BoostQuery.class::cast) .map(BoostQuery.class::cast)
.filter(x -> ((TermQuery) x.getQuery()).getTerm().text().equals("lucene")) .filter(x -> ((TermQuery) x.getQuery()).getTerm().text().equals("lucene"))
.mapToDouble(BoostQuery::getBoost) .mapToDouble(BoostQuery::getBoost)
@ -596,7 +596,7 @@ public class TestMoreLikeThis extends LuceneTestCase {
final double boost1 = final double boost1 =
((BooleanQuery) mlt.like("text", new StringReader("lucene|1 release|1"))) ((BooleanQuery) mlt.like("text", new StringReader("lucene|1 release|1")))
.clauses().stream() .clauses().stream()
.map(BooleanClause::getQuery) .map(BooleanClause::query)
.map(BoostQuery.class::cast) .map(BoostQuery.class::cast)
.filter(x -> ((TermQuery) x.getQuery()).getTerm().text().equals("lucene")) .filter(x -> ((TermQuery) x.getQuery()).getTerm().text().equals("lucene"))
.mapToDouble(BoostQuery::getBoost) .mapToDouble(BoostQuery::getBoost)

2
lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/MultiFieldQueryParser.java
View File

@ -168,7 +168,7 @@ public class MultiFieldQueryParser extends QueryParser {
if (fieldQueries[i] instanceof BooleanQuery) { if (fieldQueries[i] instanceof BooleanQuery) {
List<BooleanClause> nestedClauses = ((BooleanQuery) fieldQueries[i]).clauses(); List<BooleanClause> nestedClauses = ((BooleanQuery) fieldQueries[i]).clauses();
if (termNum < nestedClauses.size()) { if (termNum < nestedClauses.size()) {
q = nestedClauses.get(termNum).getQuery(); q = nestedClauses.get(termNum).query();
} }
} else if (termNum == 0) { // e.g. TermQuery-s } else if (termNum == 0) { // e.g. TermQuery-s
q = fieldQueries[i]; q = fieldQueries[i];

8
lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserBase.java
View File

@ -371,7 +371,7 @@ public abstract class QueryParserBase extends QueryBuilder
if (clauses.size() > 0 && conj == CONJ_AND) { if (clauses.size() > 0 && conj == CONJ_AND) {
BooleanClause c = clauses.get(clauses.size() - 1); BooleanClause c = clauses.get(clauses.size() - 1);
if (!c.isProhibited()) if (!c.isProhibited())
clauses.set(clauses.size() - 1, new BooleanClause(c.getQuery(), Occur.MUST)); clauses.set(clauses.size() - 1, new BooleanClause(c.query(), Occur.MUST));
} }
if (clauses.size() > 0 && operator == AND_OPERATOR && conj == CONJ_OR) { if (clauses.size() > 0 && operator == AND_OPERATOR && conj == CONJ_OR) {
@ -381,7 +381,7 @@ public abstract class QueryParserBase extends QueryBuilder
// this modification a OR b would be parsed as +a OR b // this modification a OR b would be parsed as +a OR b
BooleanClause c = clauses.get(clauses.size() - 1); BooleanClause c = clauses.get(clauses.size() - 1);
if (!c.isProhibited()) if (!c.isProhibited())
clauses.set(clauses.size() - 1, new BooleanClause(c.getQuery(), Occur.SHOULD)); clauses.set(clauses.size() - 1, new BooleanClause(c.query(), Occur.SHOULD));
} }
// We might have been passed a null query; the term might have been // We might have been passed a null query; the term might have been
@ -428,7 +428,7 @@ public abstract class QueryParserBase extends QueryBuilder
if (q instanceof BooleanQuery) { if (q instanceof BooleanQuery) {
allNestedTermQueries = true; allNestedTermQueries = true;
for (BooleanClause clause : ((BooleanQuery) q).clauses()) { for (BooleanClause clause : ((BooleanQuery) q).clauses()) {
if (!(clause.getQuery() instanceof TermQuery)) { if (!(clause.query() instanceof TermQuery)) {
allNestedTermQueries = false; allNestedTermQueries = false;
break; break;
} }
@ -441,7 +441,7 @@ public abstract class QueryParserBase extends QueryBuilder
operator == OR_OPERATOR ? BooleanClause.Occur.SHOULD : BooleanClause.Occur.MUST; operator == OR_OPERATOR ? BooleanClause.Occur.SHOULD : BooleanClause.Occur.MUST;
if (q instanceof BooleanQuery) { if (q instanceof BooleanQuery) {
for (BooleanClause clause : ((BooleanQuery) q).clauses()) { for (BooleanClause clause : ((BooleanQuery) q).clauses()) {
clauses.add(newBooleanClause(clause.getQuery(), occur)); clauses.add(newBooleanClause(clause.query(), occur));
} }
} else { } else {
clauses.add(newBooleanClause(q, occur)); clauses.add(newBooleanClause(q, occur));

10
lucene/queryparser/src/java/org/apache/lucene/queryparser/complexPhrase/ComplexPhraseQueryParser.java
View File

@ -281,10 +281,10 @@ public class ComplexPhraseQueryParser extends QueryParser {
int i = 0; int i = 0;
for (BooleanClause clause : bq) { for (BooleanClause clause : bq) {
// HashSet bclauseterms=new HashSet(); // HashSet bclauseterms=new HashSet();
Query qc = clause.getQuery(); Query qc = clause.query();
// Rewrite this clause e.g one* becomes (one OR onerous) // Rewrite this clause e.g one* becomes (one OR onerous)
qc = indexSearcher.rewrite(qc); qc = indexSearcher.rewrite(qc);
if (clause.getOccur().equals(BooleanClause.Occur.MUST_NOT)) { if (clause.occur().equals(BooleanClause.Occur.MUST_NOT)) {
numNegatives++; numNegatives++;
} }
@ -340,7 +340,7 @@ public class ComplexPhraseQueryParser extends QueryParser {
ArrayList<SpanQuery> positiveClauses = new ArrayList<>(); ArrayList<SpanQuery> positiveClauses = new ArrayList<>();
i = 0; i = 0;
for (BooleanClause clause : bq) { for (BooleanClause clause : bq) {
if (!clause.getOccur().equals(BooleanClause.Occur.MUST_NOT)) { if (!clause.occur().equals(BooleanClause.Occur.MUST_NOT)) {
positiveClauses.add(allSpanClauses[i]); positiveClauses.add(allSpanClauses[i]);
} }
i += 1; i += 1;
@ -376,7 +376,7 @@ public class ComplexPhraseQueryParser extends QueryParser {
// For all clauses e.g. one* two~ // For all clauses e.g. one* two~
for (BooleanClause clause : qc) { for (BooleanClause clause : qc) {
Query childQuery = clause.getQuery(); Query childQuery = clause.query();
while (childQuery instanceof BoostQuery) { while (childQuery instanceof BoostQuery) {
BoostQuery bq = (BoostQuery) childQuery; BoostQuery bq = (BoostQuery) childQuery;
@ -385,7 +385,7 @@ public class ComplexPhraseQueryParser extends QueryParser {
// select the list to which we will add these options // select the list to which we will add these options
ArrayList<SpanQuery> chosenList = ors; ArrayList<SpanQuery> chosenList = ors;
if (clause.getOccur() == BooleanClause.Occur.MUST_NOT) { if (clause.occur() == BooleanClause.Occur.MUST_NOT) {
chosenList = nots; chosenList = nots;
} }

2
lucene/queryparser/src/java/org/apache/lucene/queryparser/simple/SimpleQueryParser.java
View File

@ -620,7 +620,7 @@ public class SimpleQueryParser extends QueryBuilder {
if (bq.clauses().isEmpty()) { if (bq.clauses().isEmpty()) {
return null; return null;
} else if (bq.clauses().size() == 1) { } else if (bq.clauses().size() == 1) {
return bq.clauses().iterator().next().getQuery(); return bq.clauses().iterator().next().query();
} else { } else {
return bq; return bq;
} }

4
lucene/queryparser/src/test/org/apache/lucene/queryparser/ext/TestExtendableQueryParser.java
View File

@ -75,7 +75,7 @@ public class TestExtendableQueryParser extends TestQueryParser {
BooleanClause[] clauses = bquery.clauses().toArray(new BooleanClause[0]); BooleanClause[] clauses = bquery.clauses().toArray(new BooleanClause[0]);
assertEquals(2, clauses.length); assertEquals(2, clauses.length);
BooleanClause booleanClause = clauses[0]; BooleanClause booleanClause = clauses[0];
query = booleanClause.getQuery(); query = booleanClause.query();
assertTrue( assertTrue(
"expected instance of TermQuery but was " + query.getClass(), query instanceof TermQuery); "expected instance of TermQuery but was " + query.getClass(), query instanceof TermQuery);
TermQuery tquery = (TermQuery) query; TermQuery tquery = (TermQuery) query;
@ -83,7 +83,7 @@ public class TestExtendableQueryParser extends TestQueryParser {
assertEquals("foo", tquery.getTerm().text()); assertEquals("foo", tquery.getTerm().text());
booleanClause = clauses[1]; booleanClause = clauses[1];
query = booleanClause.getQuery(); query = booleanClause.query();
assertTrue( assertTrue(
"expected instance of TermQuery but was " + query.getClass(), query instanceof TermQuery); "expected instance of TermQuery but was " + query.getClass(), query instanceof TermQuery);
tquery = (TermQuery) query; tquery = (TermQuery) query;

2
lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/standard/TestQPHelper.java
View File

@ -1261,7 +1261,7 @@ public class TestQPHelper extends LuceneTestCase {
assertEquals(new MatchAllDocsQuery(), qp.parse("(*:*)", "field")); assertEquals(new MatchAllDocsQuery(), qp.parse("(*:*)", "field"));
BooleanQuery bq = (BooleanQuery) qp.parse("+*:* -*:*", "field"); BooleanQuery bq = (BooleanQuery) qp.parse("+*:* -*:*", "field");
for (BooleanClause c : bq) { for (BooleanClause c : bq) {
assertTrue(c.getQuery().getClass() == MatchAllDocsQuery.class); assertTrue(c.query().getClass() == MatchAllDocsQuery.class);
} }
} }

2
lucene/queryparser/src/test/org/apache/lucene/queryparser/util/QueryParserTestBase.java
View File

@ -1145,7 +1145,7 @@ public abstract class QueryParserTestBase extends LuceneTestCase {
BooleanQuery bq = (BooleanQuery) getQuery("+*:* -*:*", qp); BooleanQuery bq = (BooleanQuery) getQuery("+*:* -*:*", qp);
assertEquals(2, bq.clauses().size()); assertEquals(2, bq.clauses().size());
for (BooleanClause clause : bq) { for (BooleanClause clause : bq) {
assertTrue(clause.getQuery() instanceof MatchAllDocsQuery); assertTrue(clause.query() instanceof MatchAllDocsQuery);
} }
} }

2
lucene/sandbox/src/java/org/apache/lucene/payloads/PayloadSpanUtil.java
View File

@ -75,7 +75,7 @@ public class PayloadSpanUtil {
if (query instanceof BooleanQuery) { if (query instanceof BooleanQuery) {
for (BooleanClause clause : (BooleanQuery) query) { for (BooleanClause clause : (BooleanQuery) query) {
if (!clause.isProhibited()) { if (!clause.isProhibited()) {
queryToSpanQuery(clause.getQuery(), payloads); queryToSpanQuery(clause.query(), payloads);
} }
} }

2
lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/AnalyzingInfixSuggester.java
View File

@ -695,7 +695,7 @@ public class AnalyzingInfixSuggester extends Lookup implements Closeable {
if (contextQuery != null) { if (contextQuery != null) {
boolean allMustNot = true; boolean allMustNot = true;
for (BooleanClause clause : contextQuery.clauses()) { for (BooleanClause clause : contextQuery.clauses()) {
if (clause.getOccur() != BooleanClause.Occur.MUST_NOT) { if (clause.occur() != BooleanClause.Occur.MUST_NOT) {
allMustNot = false; allMustNot = false;
break; break;
} }