Apache Lucene open-source search software
Convert BooleanClause class to record class (#13261)
Pulkit Gupta2ee537ce160f
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txtindex 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.mdindex 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 toaccess 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.javaindex 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.javaindex 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 lookupsif (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 clauseactuallyRewritten = true;@@ -287,11 +287,11 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {// optimize 1-clause queriesif (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 nowBooleanQuery.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 parensbuffer.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.javaindex 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.javaindex 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.javaindex 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<BooleanClauseint 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 parensbuffer.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.javaindex 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.javaindex 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.javaindex 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.javaindex 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.javaindex 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.javaindex 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 termsdiff --git a/lucene/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java b/lucene/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.javaindex 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.javaindex 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());}} elsethrow 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.javaindex 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.javaindex 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.javaindex 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.javaindex 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 queryfor (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 queryfor (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.javaindex 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-sq = 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.javaindex 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 QueryBuilderif (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 bBooleanClause 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 QueryBuilderif (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 QueryBuilderoperator == 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.javaindex 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 optionsArrayList<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.javaindex 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.javaindex 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.javaindex 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.javaindex 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.javaindex 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.javaindex 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;}