Skip to content

Apache Lucene open-source search software

Convert BooleanClause class to record class (#13261)

Pulkit Gupta2ee537ce160f
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt
index c79579a61e5..09a87abebe4 100644
--- a/lucene/CHANGES.txt
+++ b/lucene/CHANGES.txt
@@ -94,6 +94,8 @@ API Changes
* GITHUB#13242: Replace `IOContext.READ` with `IOContext.DEFAULT`. (Adrien Grand)
+* GITHUB#13261: Convert `BooleanClause` class to record class. (Pulkit Gupta)
+
New Features
---------------------
diff --git a/lucene/MIGRATE.md b/lucene/MIGRATE.md
index e8e70a642e8..dcd55d0503e 100644
--- a/lucene/MIGRATE.md
+++ b/lucene/MIGRATE.md
@@ -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:
- `IOContext`, `MergeInfo`, and `FlushInfo` (GITHUB#13205)
+- `BooleanClause` (GITHUB#13261)
### Boolean flags on IOContext replaced with a new ReadAdvice enum.
diff --git a/lucene/core/src/java/org/apache/lucene/search/BooleanClause.java b/lucene/core/src/java/org/apache/lucene/search/BooleanClause.java
index 7d52cdec77c..f888b379ca5 100644
--- a/lucene/core/src/java/org/apache/lucene/search/BooleanClause.java
+++ b/lucene/core/src/java/org/apache/lucene/search/BooleanClause.java
@@ -19,7 +19,7 @@ package org.apache.lucene.search;
import java.util.Objects;
/** 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. */
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. */
- public BooleanClause(Query query, Occur occur) {
- this.query = Objects.requireNonNull(query, "Query must not be null");
- this.occur = Objects.requireNonNull(occur, "Occur must not be null");
- }
-
- public Occur getOccur() {
- return occur;
- }
-
- public Query getQuery() {
- return query;
+ public BooleanClause {
+ Objects.requireNonNull(query, "Query must not be null");
+ Objects.requireNonNull(occur, "Occur must not be null");
}
public boolean isProhibited() {
@@ -97,23 +84,4 @@ public final class BooleanClause {
public boolean isScoring() {
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();
- }
}
diff --git a/lucene/core/src/java/org/apache/lucene/search/BooleanQuery.java b/lucene/core/src/java/org/apache/lucene/search/BooleanQuery.java
index 2d84a44ba22..8a2e866f487 100644
--- a/lucene/core/src/java/org/apache/lucene/search/BooleanQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/BooleanQuery.java
@@ -153,7 +153,7 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
clauseSets.put(Occur.FILTER, new HashSet<>());
clauseSets.put(Occur.MUST_NOT, new HashSet<>());
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() {
return clauses.size() == 2
&& isPureDisjunction()
- && clauses.get(0).getQuery() instanceof TermQuery
- && clauses.get(1).getQuery() instanceof TermQuery;
+ && clauses.get(0).query() 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();
Query[] queries = new Query[3];
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
// dictionary lookups
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);
for (BooleanClause clause : clauses) {
- Query query = clause.getQuery();
+ Query query = clause.query();
// NOTE: rewritingNoScoring() should not call rewrite(), otherwise this
// method could run in exponential time with the depth of the query as
// 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) {
rewritten = ((BooleanQuery) rewritten).rewriteNoScoring();
}
- BooleanClause.Occur occur = clause.getOccur();
+ BooleanClause.Occur occur = clause.occur();
if (occur == Occur.SHOULD && keepShould == false) {
// ignore clause
actuallyRewritten = true;
@@ -287,11 +287,11 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
// optimize 1-clause queries
if (clauses.size() == 1) {
BooleanClause c = clauses.get(0);
- Query query = c.getQuery();
- if (minimumNumberShouldMatch == 1 && c.getOccur() == Occur.SHOULD) {
+ Query query = c.query();
+ if (minimumNumberShouldMatch == 1 && c.occur() == Occur.SHOULD) {
return query;
} else if (minimumNumberShouldMatch == 0) {
- switch (c.getOccur()) {
+ switch (c.occur()) {
case SHOULD:
case MUST:
return query;
@@ -313,8 +313,8 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
builder.setMinimumNumberShouldMatch(getMinimumNumberShouldMatch());
boolean actuallyRewritten = false;
for (BooleanClause clause : this) {
- Query query = clause.getQuery();
- BooleanClause.Occur occur = clause.getOccur();
+ Query query = clause.query();
+ BooleanClause.Occur occur = clause.occur();
Query rewritten;
if (occur == Occur.FILTER || occur == Occur.MUST_NOT) {
// 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();
builder.setMinimumNumberShouldMatch(getMinimumNumberShouldMatch());
for (BooleanClause clause : clauses) {
- if (clause.getOccur() != Occur.FILTER) {
+ if (clause.occur() != Occur.FILTER) {
builder.add(clause);
}
}
@@ -420,9 +420,9 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
int minShouldMatch = getMinimumNumberShouldMatch();
for (BooleanClause clause : clauses) {
- if (intersection.contains(clause.getQuery())) {
- if (clause.getOccur() == Occur.SHOULD) {
- builder.add(new BooleanClause(clause.getQuery(), Occur.MUST));
+ if (intersection.contains(clause.query())) {
+ if (clause.occur() == Occur.SHOULD) {
+ builder.add(new BooleanClause(clause.query(), Occur.MUST));
minShouldMatch--;
}
} else {
@@ -459,7 +459,7 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
builder.add(query, Occur.SHOULD);
}
for (BooleanClause clause : clauses) {
- if (clause.getOccur() != Occur.SHOULD) {
+ if (clause.occur() != Occur.SHOULD) {
builder.add(clause);
}
}
@@ -491,7 +491,7 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
builder.add(query, Occur.MUST);
}
for (BooleanClause clause : clauses) {
- if (clause.getOccur() != Occur.MUST) {
+ if (clause.occur() != Occur.MUST) {
builder.add(clause);
}
}
@@ -517,7 +517,7 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
// ignore SHOULD clause for now
BooleanQuery.Builder builder = new BooleanQuery.Builder();
for (BooleanClause clause : clauses) {
- switch (clause.getOccur()) {
+ switch (clause.occur()) {
case FILTER:
case MUST_NOT:
builder.add(clause);
@@ -555,8 +555,8 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
builder.setMinimumNumberShouldMatch(minimumNumberShouldMatch);
boolean actuallyRewritten = false;
for (BooleanClause clause : clauses) {
- if (clause.getOccur() == Occur.SHOULD && clause.getQuery() instanceof BooleanQuery) {
- BooleanQuery innerQuery = (BooleanQuery) clause.getQuery();
+ if (clause.occur() == Occur.SHOULD && clause.query() instanceof BooleanQuery) {
+ BooleanQuery innerQuery = (BooleanQuery) clause.query();
if (innerQuery.isPureDisjunction()) {
actuallyRewritten = true;
for (BooleanClause innerClause : innerQuery.clauses()) {
@@ -586,8 +586,8 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
if (shoulds.size() == minimumNumberShouldMatch) {
BooleanQuery.Builder builder = new BooleanQuery.Builder();
for (BooleanClause clause : clauses) {
- if (clause.getOccur() == Occur.SHOULD) {
- builder.add(clause.getQuery(), Occur.MUST);
+ if (clause.occur() == Occur.SHOULD) {
+ builder.add(clause.query(), Occur.MUST);
} else {
builder.add(clause);
}
@@ -631,9 +631,9 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
int i = 0;
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
buffer.append("(");
buffer.append(subQuery.toString(field));
diff --git a/lucene/core/src/java/org/apache/lucene/search/BooleanWeight.java b/lucene/core/src/java/org/apache/lucene/search/BooleanWeight.java
index d55007679a0..2fb4dab366b 100644
--- a/lucene/core/src/java/org/apache/lucene/search/BooleanWeight.java
+++ b/lucene/core/src/java/org/apache/lucene/search/BooleanWeight.java
@@ -59,7 +59,7 @@ final class BooleanWeight extends Weight {
for (BooleanClause c : query) {
Weight w =
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));
}
}
@@ -87,20 +87,18 @@ final class BooleanWeight extends Weight {
e));
} else if (c.isProhibited()) {
subs.add(
- Explanation.noMatch(
- "match on prohibited clause (" + c.getQuery().toString() + ")", e));
+ Explanation.noMatch("match on prohibited clause (" + c.query().toString() + ")", e));
fail = true;
}
if (!c.isProhibited()) {
matchCount++;
}
- if (c.getOccur() == Occur.SHOULD) {
+ if (c.occur() == Occur.SHOULD) {
shouldMatchCount++;
}
} else if (c.isRequired()) {
subs.add(
- Explanation.noMatch(
- "no match on required clause (" + c.getQuery().toString() + ")", e));
+ Explanation.noMatch("no match on required clause (" + c.query().toString() + ")", e));
fail = true;
}
}
@@ -145,7 +143,7 @@ final class BooleanWeight extends Weight {
}
matches.add(m);
}
- if (bc.getOccur() == Occur.SHOULD) {
+ if (bc.occur() == Occur.SHOULD) {
if (m != null) {
matches.add(m);
shouldMatchCount++;
@@ -202,7 +200,7 @@ final class BooleanWeight extends Weight {
for (WeightedBooleanClause wc : weightedClauses) {
Weight w = wc.weight;
BooleanClause c = wc.clause;
- if (c.getOccur() != Occur.SHOULD) {
+ if (c.occur() != Occur.SHOULD) {
continue;
}
ScorerSupplier scorer = w.scorerSupplier(context);
@@ -227,7 +225,7 @@ final class BooleanWeight extends Weight {
for (WeightedBooleanClause wc : weightedClauses) {
Weight w = wc.weight;
BooleanClause c = wc.clause;
- if (c.getOccur() != Occur.SHOULD) {
+ if (c.occur() != Occur.SHOULD) {
continue;
}
BulkScorer subScorer = w.bulkScorer(context);
@@ -525,7 +523,7 @@ final class BooleanWeight extends Weight {
int optCount = 0;
boolean unknownCount = false;
for (WeightedBooleanClause weightedClause : weightedClauses) {
- if (weightedClause.clause.getOccur() != occur) {
+ if (weightedClause.clause.occur() != occur) {
continue;
}
int count = weightedClause.weight.count(context);
@@ -598,7 +596,7 @@ final class BooleanWeight extends Weight {
return null;
}
} else {
- scorers.get(c.getOccur()).add(subScorer);
+ scorers.get(c.occur()).add(subScorer);
}
}
diff --git a/lucene/core/src/java/org/apache/lucene/search/IndriAndWeight.java b/lucene/core/src/java/org/apache/lucene/search/IndriAndWeight.java
index ee75a9c2fe1..f23c9284d20 100644
--- a/lucene/core/src/java/org/apache/lucene/search/IndriAndWeight.java
+++ b/lucene/core/src/java/org/apache/lucene/search/IndriAndWeight.java
@@ -39,7 +39,7 @@ public class IndriAndWeight extends Weight {
this.scoreMode = scoreMode;
weights = new ArrayList<>();
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);
}
}
@@ -100,8 +100,7 @@ public class IndriAndWeight extends Weight {
subs.add(e);
} else if (c.isRequired()) {
subs.add(
- Explanation.noMatch(
- "no match on required clause (" + c.getQuery().toString() + ")", e));
+ Explanation.noMatch("no match on required clause (" + c.query().toString() + ")", e));
fail = true;
}
}
diff --git a/lucene/core/src/java/org/apache/lucene/search/IndriQuery.java b/lucene/core/src/java/org/apache/lucene/search/IndriQuery.java
index 7fed297fd8e..1a555cd7474 100644
--- a/lucene/core/src/java/org/apache/lucene/search/IndriQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/IndriQuery.java
@@ -43,9 +43,9 @@ public abstract class IndriQuery extends Query implements Iterable<BooleanClause
int i = 0;
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
buffer.append("(");
buffer.append(subQuery.toString(field));
diff --git a/lucene/core/src/java/org/apache/lucene/util/QueryBuilder.java b/lucene/core/src/java/org/apache/lucene/util/QueryBuilder.java
index 91861527ea7..5dcc3a6ee53 100644
--- a/lucene/core/src/java/org/apache/lucene/util/QueryBuilder.java
+++ b/lucene/core/src/java/org/apache/lucene/util/QueryBuilder.java
@@ -624,7 +624,7 @@ public class QueryBuilder {
}
BooleanQuery bq = builder.build();
if (bq.clauses().size() == 1) {
- return bq.clauses().get(0).getQuery();
+ return bq.clauses().get(0).query();
}
return bq;
}
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestBooleanMinShouldMatch.java b/lucene/core/src/test/org/apache/lucene/search/TestBooleanMinShouldMatch.java
index 159ba4f2153..4faa78f4bd9 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestBooleanMinShouldMatch.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestBooleanMinShouldMatch.java
@@ -320,7 +320,7 @@ public class TestBooleanMinShouldMatch extends LuceneTestCase {
public void postCreate(BooleanQuery.Builder q) {
int opt = 0;
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));
if (random().nextBoolean()) {
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java
index 5ba9b7df5b5..d81e98beac9 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java
@@ -474,7 +474,7 @@ public class TestBooleanQuery extends LuceneTestCase {
throws IOException {
final BooleanQuery.Builder bq2Builder = new BooleanQuery.Builder();
for (BooleanClause c : bq) {
- if (c.getOccur() != Occur.FILTER) {
+ if (c.occur() != Occur.FILTER) {
bq2Builder.add(c);
}
}
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestMinShouldMatch2.java b/lucene/core/src/test/org/apache/lucene/search/TestMinShouldMatch2.java
index 1b6d0778a2e..1c0c15431b8 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestMinShouldMatch2.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestMinShouldMatch2.java
@@ -360,7 +360,7 @@ public class TestMinShouldMatch2 extends LuceneTestCase {
for (BooleanClause clause : bq.clauses()) {
assert !clause.isProhibited();
assert !clause.isRequired();
- Term term = ((TermQuery) clause.getQuery()).getTerm();
+ Term term = ((TermQuery) clause.query()).getTerm();
long ord = dv.lookupTerm(term.bytes());
if (ord >= 0) {
boolean success = ords.add(ord);
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java b/lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java
index 451e7648765..78fab5a5633 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java
@@ -111,7 +111,7 @@ public class TestMultiTermQueryRewrites extends LuceneTestCase {
final BooleanQuery bq = (BooleanQuery) q;
Term last = null, act;
for (BooleanClause clause : bq.clauses()) {
- act = extractTerm(clause.getQuery());
+ act = extractTerm(clause.query());
if (last != null) {
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) {
for (BooleanClause clause : bq.clauses()) {
- final BoostQuery boostQ = (BoostQuery) clause.getQuery();
+ final BoostQuery boostQ = (BoostQuery) clause.query();
final TermQuery mtq = (TermQuery) boostQ.getQuery();
assertEquals(
"Parallel sorting of boosts in rewrite mode broken",
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java
index 8dd192e6a1e..7f4ad686baa 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java
@@ -150,8 +150,8 @@ public class TestTermRangeQuery extends LuceneTestCase {
final Set<String> allowedTerms = asSet(terms);
assertEquals(allowedTerms.size(), bq.clauses().size());
for (BooleanClause c : bq.clauses()) {
- assertTrue(c.getQuery() instanceof TermQuery);
- final TermQuery tq = (TermQuery) c.getQuery();
+ assertTrue(c.query() instanceof TermQuery);
+ final TermQuery tq = (TermQuery) c.query();
final String term = tq.getTerm().text();
assertTrue("invalid term: " + term, allowedTerms.contains(term));
allowedTerms.remove(term); // remove to fail on double terms
diff --git a/lucene/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java b/lucene/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java
index 6c67dc98d56..c4cd50274f1 100644
--- a/lucene/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java
+++ b/lucene/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java
@@ -133,7 +133,7 @@ public class WeightedSpanTermExtractor {
} else if (query instanceof BooleanQuery) {
for (BooleanClause clause : (BooleanQuery) query) {
if (!clause.isProhibited()) {
- extract(clause.getQuery(), boost, terms);
+ extract(clause.query(), boost, terms);
}
}
} else if (query instanceof PhraseQuery) {
diff --git a/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/FieldQuery.java b/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/FieldQuery.java
index d89b34d8abd..2351e6c08f9 100644
--- a/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/FieldQuery.java
+++ b/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/FieldQuery.java
@@ -114,7 +114,7 @@ public class FieldQuery {
BooleanQuery bq = (BooleanQuery) sourceQuery;
for (BooleanClause clause : bq) {
if (!clause.isProhibited()) {
- flatten(clause.getQuery(), searcher, flatQueries, boost);
+ flatten(clause.query(), searcher, flatQueries, boost);
}
}
} else if (sourceQuery instanceof DisjunctionMaxQuery) {
@@ -330,7 +330,7 @@ public class FieldQuery {
} else if (query instanceof MultiTermQuery && searcher != null) {
BooleanQuery mtqTerms = (BooleanQuery) query.rewrite(searcher);
for (BooleanClause clause : mtqTerms) {
- termSet.add(((TermQuery) clause.getQuery()).getTerm().text());
+ termSet.add(((TermQuery) clause.query()).getTerm().text());
}
} else
throw new RuntimeException("query \"" + query.toString() + "\" must be flatten first.");
diff --git a/lucene/monitor/src/java/org/apache/lucene/monitor/QueryAnalyzer.java b/lucene/monitor/src/java/org/apache/lucene/monitor/QueryAnalyzer.java
index 9fe8c56a6eb..11319be44d9 100644
--- a/lucene/monitor/src/java/org/apache/lucene/monitor/QueryAnalyzer.java
+++ b/lucene/monitor/src/java/org/apache/lucene/monitor/QueryAnalyzer.java
@@ -84,9 +84,7 @@ class QueryAnalyzer {
if (parent instanceof BooleanQuery) {
BooleanQuery bq = (BooleanQuery) parent;
long positiveCount =
- bq.clauses().stream()
- .filter(c -> c.getOccur() != BooleanClause.Occur.MUST_NOT)
- .count();
+ bq.clauses().stream().filter(c -> c.occur() != BooleanClause.Occur.MUST_NOT).count();
if (positiveCount == 0) {
children.add(w -> QueryTree.anyTerm("PURE NEGATIVE QUERY[" + parent + "]"));
}
@@ -101,8 +99,8 @@ class QueryAnalyzer {
bq.clauses().stream()
.filter(
c ->
- c.getOccur() == BooleanClause.Occur.MUST
- || c.getOccur() == BooleanClause.Occur.FILTER)
+ c.occur() == BooleanClause.Occur.MUST
+ || c.occur() == BooleanClause.Occur.FILTER)
.count();
if (requiredCount > 0) {
return QueryVisitor.EMPTY_VISITOR;
diff --git a/lucene/monitor/src/java/org/apache/lucene/monitor/QueryDecomposer.java b/lucene/monitor/src/java/org/apache/lucene/monitor/QueryDecomposer.java
index 81679f8bb55..a3469362036 100644
--- a/lucene/monitor/src/java/org/apache/lucene/monitor/QueryDecomposer.java
+++ b/lucene/monitor/src/java/org/apache/lucene/monitor/QueryDecomposer.java
@@ -82,11 +82,11 @@ public class QueryDecomposer {
Set<Query> mandatory = new HashSet<>();
for (BooleanClause clause : q) {
- if (clause.getOccur() == BooleanClause.Occur.MUST
- || clause.getOccur() == BooleanClause.Occur.FILTER) mandatory.add(clause.getQuery());
- else if (clause.getOccur() == BooleanClause.Occur.MUST_NOT) exclusions.add(clause.getQuery());
+ if (clause.occur() == BooleanClause.Occur.MUST
+ || clause.occur() == BooleanClause.Occur.FILTER) mandatory.add(clause.query());
+ else if (clause.occur() == BooleanClause.Occur.MUST_NOT) exclusions.add(clause.query());
else {
- subqueries.addAll(decompose(clause.getQuery()));
+ subqueries.addAll(decompose(clause.query()));
}
}
diff --git a/lucene/monitor/src/test/org/apache/lucene/monitor/TestBooleanTermExtractor.java b/lucene/monitor/src/test/org/apache/lucene/monitor/TestBooleanTermExtractor.java
index 80d8f3379f2..adb4ca6244d 100644
--- a/lucene/monitor/src/test/org/apache/lucene/monitor/TestBooleanTermExtractor.java
+++ b/lucene/monitor/src/test/org/apache/lucene/monitor/TestBooleanTermExtractor.java
@@ -81,8 +81,8 @@ public class TestBooleanTermExtractor extends LuceneTestCase {
Query q = MonitorTestBase.parse("+*:*");
assertTrue(q instanceof BooleanQuery);
BooleanClause clause = ((BooleanQuery) q).iterator().next();
- assertTrue(clause.getQuery() instanceof MatchAllDocsQuery);
- assertEquals(BooleanClause.Occur.MUST, clause.getOccur());
+ assertTrue(clause.query() instanceof MatchAllDocsQuery);
+ assertEquals(BooleanClause.Occur.MUST, clause.occur());
Set<Term> terms = collectTerms(q);
assertEquals(1, terms.size());
diff --git a/lucene/queries/src/test/org/apache/lucene/queries/mlt/TestMoreLikeThis.java b/lucene/queries/src/test/org/apache/lucene/queries/mlt/TestMoreLikeThis.java
index b5b51701454..90c962b04d2 100644
--- a/lucene/queries/src/test/org/apache/lucene/queries/mlt/TestMoreLikeThis.java
+++ b/lucene/queries/src/test/org/apache/lucene/queries/mlt/TestMoreLikeThis.java
@@ -166,18 +166,18 @@ public class TestMoreLikeThis extends LuceneTestCase {
List<BooleanClause> clauses = query.clauses();
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"));
- term = ((TermQuery) clauses.get(1).getQuery()).getTerm();
+ term = ((TermQuery) clauses.get(1).query()).getTerm();
assertTrue(term.text().equals("tenth"));
query = (BooleanQuery) mlt.like("one_percent", new StringReader("tenth all all"));
clauses = query.clauses();
assertTrue(clauses.size() == 2);
- term = ((TermQuery) clauses.get(0).getQuery()).getTerm();
+ term = ((TermQuery) clauses.get(0).query()).getTerm();
assertTrue(term.text().equals("all"));
- term = ((TermQuery) clauses.get(1).getQuery()).getTerm();
+ term = ((TermQuery) clauses.get(1).query()).getTerm();
assertTrue(term.text().equals("tenth"));
// clean up
@@ -203,7 +203,7 @@ public class TestMoreLikeThis extends LuceneTestCase {
"Expected " + originalValues.size() + " clauses.", originalValues.size(), clauses.size());
for (BooleanClause clause : clauses) {
- BoostQuery bq = (BoostQuery) clause.getQuery();
+ BoostQuery bq = (BoostQuery) clause.query();
TermQuery tq = (TermQuery) bq.getQuery();
Float termBoost = originalValues.get(tq.getTerm().text());
assertNotNull("Expected term " + tq.getTerm().text(), termBoost);
@@ -230,7 +230,7 @@ public class TestMoreLikeThis extends LuceneTestCase {
Collection<BooleanClause> clauses = query.clauses();
for (BooleanClause clause : clauses) {
- BoostQuery bq = (BoostQuery) clause.getQuery();
+ BoostQuery bq = (BoostQuery) clause.query();
TermQuery tq = (TermQuery) bq.getQuery();
originalValues.put(tq.getTerm().text(), bq.getBoost());
}
@@ -260,7 +260,7 @@ public class TestMoreLikeThis extends LuceneTestCase {
Collection<BooleanClause> clauses = query.clauses();
assertEquals("Expected 2 clauses only!", 2, clauses.size());
for (BooleanClause clause : clauses) {
- Term term = ((TermQuery) clause.getQuery()).getTerm();
+ Term term = ((TermQuery) clause.query()).getTerm();
assertTrue(
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();
assertEquals("Expected 1 clauses only!", 1, clauses.size());
for (BooleanClause clause : clauses) {
- Term term = ((TermQuery) clause.getQuery()).getTerm();
+ Term term = ((TermQuery) clause.query()).getTerm();
assertEquals(new Term(mltField1, "lucene"), term);
}
analyzer.close();
@@ -319,7 +319,7 @@ public class TestMoreLikeThis extends LuceneTestCase {
// None of the Not Expected terms is in the query
for (BooleanClause clause : clauses) {
- Term term = ((TermQuery) clause.getQuery()).getTerm();
+ Term term = ((TermQuery) clause.query()).getTerm();
assertFalse(
"Unexpected term '" + term + "' found in query terms", unexpectedTerms.contains(term));
}
@@ -358,7 +358,7 @@ public class TestMoreLikeThis extends LuceneTestCase {
Collection<BooleanClause> clauses = query.clauses();
HashSet<Term> clausesTerms = new HashSet<>();
for (BooleanClause clause : clauses) {
- Term term = ((TermQuery) clause.getQuery()).getTerm();
+ Term term = ((TermQuery) clause.query()).getTerm();
clausesTerms.add(term);
}
@@ -366,7 +366,7 @@ public class TestMoreLikeThis extends LuceneTestCase {
// None of the Not Expected terms is in the query
for (BooleanClause clause : clauses) {
- Term term = ((TermQuery) clause.getQuery()).getTerm();
+ Term term = ((TermQuery) clause.query()).getTerm();
assertFalse(
"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);
}
for (BooleanClause clause : clauses) {
- Term term = ((TermQuery) clause.getQuery()).getTerm();
+ Term term = ((TermQuery) clause.query()).getTerm();
assertTrue(Arrays.asList(expectedTerms).contains(term));
}
@@ -587,7 +587,7 @@ public class TestMoreLikeThis extends LuceneTestCase {
final double boost10 =
((BooleanQuery) mlt.like("text", new StringReader("lucene|10 release|1")))
.clauses().stream()
- .map(BooleanClause::getQuery)
+ .map(BooleanClause::query)
.map(BoostQuery.class::cast)
.filter(x -> ((TermQuery) x.getQuery()).getTerm().text().equals("lucene"))
.mapToDouble(BoostQuery::getBoost)
@@ -596,7 +596,7 @@ public class TestMoreLikeThis extends LuceneTestCase {
final double boost1 =
((BooleanQuery) mlt.like("text", new StringReader("lucene|1 release|1")))
.clauses().stream()
- .map(BooleanClause::getQuery)
+ .map(BooleanClause::query)
.map(BoostQuery.class::cast)
.filter(x -> ((TermQuery) x.getQuery()).getTerm().text().equals("lucene"))
.mapToDouble(BoostQuery::getBoost)
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/MultiFieldQueryParser.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/MultiFieldQueryParser.java
index 149f993991c..07e1b75cbd8 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/MultiFieldQueryParser.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/MultiFieldQueryParser.java
@@ -168,7 +168,7 @@ public class MultiFieldQueryParser extends QueryParser {
if (fieldQueries[i] instanceof BooleanQuery) {
List<BooleanClause> nestedClauses = ((BooleanQuery) fieldQueries[i]).clauses();
if (termNum < nestedClauses.size()) {
- q = nestedClauses.get(termNum).getQuery();
+ q = nestedClauses.get(termNum).query();
}
} else if (termNum == 0) { // e.g. TermQuery-s
q = fieldQueries[i];
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserBase.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserBase.java
index e7d8c55d723..20aae1e9f2d 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserBase.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserBase.java
@@ -371,7 +371,7 @@ public abstract class QueryParserBase extends QueryBuilder
if (clauses.size() > 0 && conj == CONJ_AND) {
BooleanClause c = clauses.get(clauses.size() - 1);
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) {
@@ -381,7 +381,7 @@ public abstract class QueryParserBase extends QueryBuilder
// this modification a OR b would be parsed as +a OR b
BooleanClause c = clauses.get(clauses.size() - 1);
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
@@ -428,7 +428,7 @@ public abstract class QueryParserBase extends QueryBuilder
if (q instanceof BooleanQuery) {
allNestedTermQueries = true;
for (BooleanClause clause : ((BooleanQuery) q).clauses()) {
- if (!(clause.getQuery() instanceof TermQuery)) {
+ if (!(clause.query() instanceof TermQuery)) {
allNestedTermQueries = false;
break;
}
@@ -441,7 +441,7 @@ public abstract class QueryParserBase extends QueryBuilder
operator == OR_OPERATOR ? BooleanClause.Occur.SHOULD : BooleanClause.Occur.MUST;
if (q instanceof BooleanQuery) {
for (BooleanClause clause : ((BooleanQuery) q).clauses()) {
- clauses.add(newBooleanClause(clause.getQuery(), occur));
+ clauses.add(newBooleanClause(clause.query(), occur));
}
} else {
clauses.add(newBooleanClause(q, occur));
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/complexPhrase/ComplexPhraseQueryParser.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/complexPhrase/ComplexPhraseQueryParser.java
index 339e60a14bd..72a709bd4e0 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/complexPhrase/ComplexPhraseQueryParser.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/complexPhrase/ComplexPhraseQueryParser.java
@@ -281,10 +281,10 @@ public class ComplexPhraseQueryParser extends QueryParser {
int i = 0;
for (BooleanClause clause : bq) {
// HashSet bclauseterms=new HashSet();
- Query qc = clause.getQuery();
+ Query qc = clause.query();
// Rewrite this clause e.g one* becomes (one OR onerous)
qc = indexSearcher.rewrite(qc);
- if (clause.getOccur().equals(BooleanClause.Occur.MUST_NOT)) {
+ if (clause.occur().equals(BooleanClause.Occur.MUST_NOT)) {
numNegatives++;
}
@@ -340,7 +340,7 @@ public class ComplexPhraseQueryParser extends QueryParser {
ArrayList<SpanQuery> positiveClauses = new ArrayList<>();
i = 0;
for (BooleanClause clause : bq) {
- if (!clause.getOccur().equals(BooleanClause.Occur.MUST_NOT)) {
+ if (!clause.occur().equals(BooleanClause.Occur.MUST_NOT)) {
positiveClauses.add(allSpanClauses[i]);
}
i += 1;
@@ -376,7 +376,7 @@ public class ComplexPhraseQueryParser extends QueryParser {
// For all clauses e.g. one* two~
for (BooleanClause clause : qc) {
- Query childQuery = clause.getQuery();
+ Query childQuery = clause.query();
while (childQuery instanceof BoostQuery) {
BoostQuery bq = (BoostQuery) childQuery;
@@ -385,7 +385,7 @@ public class ComplexPhraseQueryParser extends QueryParser {
// select the list to which we will add these options
ArrayList<SpanQuery> chosenList = ors;
- if (clause.getOccur() == BooleanClause.Occur.MUST_NOT) {
+ if (clause.occur() == BooleanClause.Occur.MUST_NOT) {
chosenList = nots;
}
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/simple/SimpleQueryParser.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/simple/SimpleQueryParser.java
index 46945945fe7..66f191abbbb 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/simple/SimpleQueryParser.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/simple/SimpleQueryParser.java
@@ -620,7 +620,7 @@ public class SimpleQueryParser extends QueryBuilder {
if (bq.clauses().isEmpty()) {
return null;
} else if (bq.clauses().size() == 1) {
- return bq.clauses().iterator().next().getQuery();
+ return bq.clauses().iterator().next().query();
} else {
return bq;
}
diff --git a/lucene/queryparser/src/test/org/apache/lucene/queryparser/ext/TestExtendableQueryParser.java b/lucene/queryparser/src/test/org/apache/lucene/queryparser/ext/TestExtendableQueryParser.java
index 1d8b9e869f3..fed90368b03 100644
--- a/lucene/queryparser/src/test/org/apache/lucene/queryparser/ext/TestExtendableQueryParser.java
+++ b/lucene/queryparser/src/test/org/apache/lucene/queryparser/ext/TestExtendableQueryParser.java
@@ -75,7 +75,7 @@ public class TestExtendableQueryParser extends TestQueryParser {
BooleanClause[] clauses = bquery.clauses().toArray(new BooleanClause[0]);
assertEquals(2, clauses.length);
BooleanClause booleanClause = clauses[0];
- query = booleanClause.getQuery();
+ query = booleanClause.query();
assertTrue(
"expected instance of TermQuery but was " + query.getClass(), query instanceof TermQuery);
TermQuery tquery = (TermQuery) query;
@@ -83,7 +83,7 @@ public class TestExtendableQueryParser extends TestQueryParser {
assertEquals("foo", tquery.getTerm().text());
booleanClause = clauses[1];
- query = booleanClause.getQuery();
+ query = booleanClause.query();
assertTrue(
"expected instance of TermQuery but was " + query.getClass(), query instanceof TermQuery);
tquery = (TermQuery) query;
diff --git a/lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/standard/TestQPHelper.java b/lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/standard/TestQPHelper.java
index 7886624a72c..ceba4137ef0 100644
--- a/lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/standard/TestQPHelper.java
+++ b/lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/standard/TestQPHelper.java
@@ -1261,7 +1261,7 @@ public class TestQPHelper extends LuceneTestCase {
assertEquals(new MatchAllDocsQuery(), qp.parse("(*:*)", "field"));
BooleanQuery bq = (BooleanQuery) qp.parse("+*:* -*:*", "field");
for (BooleanClause c : bq) {
- assertTrue(c.getQuery().getClass() == MatchAllDocsQuery.class);
+ assertTrue(c.query().getClass() == MatchAllDocsQuery.class);
}
}
diff --git a/lucene/queryparser/src/test/org/apache/lucene/queryparser/util/QueryParserTestBase.java b/lucene/queryparser/src/test/org/apache/lucene/queryparser/util/QueryParserTestBase.java
index 16417e15814..d84a25b7312 100644
--- a/lucene/queryparser/src/test/org/apache/lucene/queryparser/util/QueryParserTestBase.java
+++ b/lucene/queryparser/src/test/org/apache/lucene/queryparser/util/QueryParserTestBase.java
@@ -1145,7 +1145,7 @@ public abstract class QueryParserTestBase extends LuceneTestCase {
BooleanQuery bq = (BooleanQuery) getQuery("+*:* -*:*", qp);
assertEquals(2, bq.clauses().size());
for (BooleanClause clause : bq) {
- assertTrue(clause.getQuery() instanceof MatchAllDocsQuery);
+ assertTrue(clause.query() instanceof MatchAllDocsQuery);
}
}
diff --git a/lucene/sandbox/src/java/org/apache/lucene/payloads/PayloadSpanUtil.java b/lucene/sandbox/src/java/org/apache/lucene/payloads/PayloadSpanUtil.java
index 48b69718d90..1631291b9ff 100644
--- a/lucene/sandbox/src/java/org/apache/lucene/payloads/PayloadSpanUtil.java
+++ b/lucene/sandbox/src/java/org/apache/lucene/payloads/PayloadSpanUtil.java
@@ -75,7 +75,7 @@ public class PayloadSpanUtil {
if (query instanceof BooleanQuery) {
for (BooleanClause clause : (BooleanQuery) query) {
if (!clause.isProhibited()) {
- queryToSpanQuery(clause.getQuery(), payloads);
+ queryToSpanQuery(clause.query(), payloads);
}
}
diff --git a/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/AnalyzingInfixSuggester.java b/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/AnalyzingInfixSuggester.java
index afaf304a4ad..426c02999f7 100644
--- a/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/AnalyzingInfixSuggester.java
+++ b/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/AnalyzingInfixSuggester.java
@@ -695,7 +695,7 @@ public class AnalyzingInfixSuggester extends Lookup implements Closeable {
if (contextQuery != null) {
boolean allMustNot = true;
for (BooleanClause clause : contextQuery.clauses()) {
- if (clause.getOccur() != BooleanClause.Occur.MUST_NOT) {
+ if (clause.occur() != BooleanClause.Occur.MUST_NOT) {
allMustNot = false;
break;
}