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#13261: Convert `BooleanClause` class to record class. (Pulkit Gupta)
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:
- `IOContext`, `MergeInfo`, and `FlushInfo` (GITHUB#13205)
- `BooleanClause` (GITHUB#13261)
### 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;
/** 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();
}
}

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.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));

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) {
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);
}
}

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;
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;
}
}

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;
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));

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

@ -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;
}

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) {
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()) {

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

@ -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);
}
}

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()) {
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);

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;
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",

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);
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

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) {
for (BooleanClause clause : (BooleanQuery) query) {
if (!clause.isProhibited()) {
extract(clause.getQuery(), boost, terms);
extract(clause.query(), boost, terms);
}
}
} 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;
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.");

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

@ -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;

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<>();
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()));
}
}

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("+*:*");
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());

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();
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)

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) {
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];

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) {
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));

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;
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;
}

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()) {
return null;
} else if (bq.clauses().size() == 1) {
return bq.clauses().iterator().next().getQuery();
return bq.clauses().iterator().next().query();
} else {
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]);
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;

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"));
BooleanQuery bq = (BooleanQuery) qp.parse("+*:* -*:*", "field");
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);
assertEquals(2, bq.clauses().size());
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) {
for (BooleanClause clause : (BooleanQuery) query) {
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) {
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;
}