You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by jp...@apache.org on 2015/06/18 09:14:07 UTC
svn commit: r1686145 [4/8] - in /lucene/dev/trunk: lucene/
lucene/analysis/common/src/test/org/apache/lucene/analysis/shingle/
lucene/benchmark/src/java/org/apache/lucene/benchmark/byTask/feeds/
lucene/benchmark/src/java/org/apache/lucene/benchmark/qua...
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSearchAfter.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSearchAfter.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSearchAfter.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSearchAfter.java Thu Jun 18 07:14:05 2015
@@ -182,10 +182,10 @@ public class TestSearchAfter extends Luc
for (int i = 0; i < n; i++) {
assertQuery(new MatchAllDocsQuery(), null);
assertQuery(new TermQuery(new Term("english", "one")), null);
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(new TermQuery(new Term("english", "one")), BooleanClause.Occur.SHOULD);
bq.add(new TermQuery(new Term("oddeven", "even")), BooleanClause.Occur.SHOULD);
- assertQuery(bq, null);
+ assertQuery(bq.build(), null);
}
}
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSimilarity.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSimilarity.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSimilarity.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSimilarity.java Thu Jun 18 07:14:05 2015
@@ -92,11 +92,11 @@ public class TestSimilarity extends Luce
}
});
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(new TermQuery(a), BooleanClause.Occur.SHOULD);
bq.add(new TermQuery(b), BooleanClause.Occur.SHOULD);
//System.out.println(bq.toString("field"));
- searcher.search(bq, new SimpleCollector() {
+ searcher.search(bq.build(), new SimpleCollector() {
private int base = 0;
private Scorer scorer;
@Override
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSimpleExplanations.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSimpleExplanations.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSimpleExplanations.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSimpleExplanations.java Thu Jun 18 07:14:05 2015
@@ -157,46 +157,46 @@ public class TestSimpleExplanations exte
public void testDMQ5() throws Exception {
DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
- BooleanQuery booleanQuery = new BooleanQuery();
+ BooleanQuery.Builder booleanQuery = new BooleanQuery.Builder();
booleanQuery.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.SHOULD);
booleanQuery.add(new TermQuery(new Term(FIELD, "QQ")), BooleanClause.Occur.MUST_NOT);
- q.add(booleanQuery);
+ q.add(booleanQuery.build());
q.add(new TermQuery(new Term(FIELD, "xx")));
qtest(q, new int[] { 2,3 });
}
public void testDMQ6() throws Exception {
DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
- BooleanQuery booleanQuery = new BooleanQuery();
+ BooleanQuery.Builder booleanQuery = new BooleanQuery.Builder();
booleanQuery.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.MUST_NOT);
booleanQuery.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.SHOULD);
- q.add(booleanQuery);
+ q.add(booleanQuery.build());
q.add(new TermQuery(new Term(FIELD, "xx")));
qtest(q, new int[] { 0,1,2,3 });
}
public void testDMQ7() throws Exception {
DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
- BooleanQuery booleanQuery = new BooleanQuery();
+ BooleanQuery.Builder booleanQuery = new BooleanQuery.Builder();
booleanQuery.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.MUST_NOT);
booleanQuery.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.SHOULD);
- q.add(booleanQuery);
+ q.add(booleanQuery.build());
q.add(new TermQuery(new Term(FIELD, "w2")));
qtest(q, new int[] { 0,1,2,3 });
}
public void testDMQ8() throws Exception {
DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
- BooleanQuery booleanQuery = new BooleanQuery();
+ BooleanQuery.Builder booleanQuery = new BooleanQuery.Builder();
booleanQuery.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.SHOULD);
TermQuery boostedQuery = new TermQuery(new Term(FIELD, "w5"));
boostedQuery.setBoost(100);
booleanQuery.add(boostedQuery, BooleanClause.Occur.SHOULD);
- q.add(booleanQuery);
+ q.add(booleanQuery.build());
TermQuery xxBoostedQuery = new TermQuery(new Term(FIELD, "xx"));
xxBoostedQuery.setBoost(100000);
@@ -207,13 +207,13 @@ public class TestSimpleExplanations exte
public void testDMQ9() throws Exception {
DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
- BooleanQuery booleanQuery = new BooleanQuery();
+ BooleanQuery.Builder booleanQuery = new BooleanQuery.Builder();
booleanQuery.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.SHOULD);
TermQuery boostedQuery = new TermQuery(new Term(FIELD, "w5"));
boostedQuery.setBoost(100);
booleanQuery.add(boostedQuery, BooleanClause.Occur.SHOULD);
- q.add(booleanQuery);
+ q.add(booleanQuery.build());
TermQuery xxBoostedQuery = new TermQuery(new Term(FIELD, "xx"));
xxBoostedQuery.setBoost(0);
@@ -266,193 +266,197 @@ public class TestSimpleExplanations exte
/* some simple tests of boolean queries containing term queries */
public void testBQ1() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);
query.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.MUST);
- qtest(query, new int[] { 0,1,2,3 });
+ qtest(query.build(), new int[] { 0,1,2,3 });
}
public void testBQ2() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.MUST);
query.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.MUST);
- qtest(query, new int[] { 2,3 });
+ qtest(query.build(), new int[] { 2,3 });
}
public void testBQ3() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.SHOULD);
query.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.MUST);
- qtest(query, new int[] { 0,1,2,3 });
+ qtest(query.build(), new int[] { 0,1,2,3 });
}
public void testBQ4() throws Exception {
- BooleanQuery outerQuery = new BooleanQuery();
+ BooleanQuery.Builder outerQuery = new BooleanQuery.Builder();
outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
- BooleanQuery innerQuery = new BooleanQuery();
+ BooleanQuery.Builder innerQuery = new BooleanQuery.Builder();
innerQuery.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
innerQuery.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.SHOULD);
- outerQuery.add(innerQuery, BooleanClause.Occur.SHOULD);
+ outerQuery.add(innerQuery.build(), BooleanClause.Occur.SHOULD);
- qtest(outerQuery, new int[] { 0,1,2,3 });
+ qtest(outerQuery.build(), new int[] { 0,1,2,3 });
}
public void testBQ5() throws Exception {
- BooleanQuery outerQuery = new BooleanQuery();
+ BooleanQuery.Builder outerQuery = new BooleanQuery.Builder();
outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
- BooleanQuery innerQuery = new BooleanQuery();
+ BooleanQuery.Builder innerQuery = new BooleanQuery.Builder();
innerQuery.add(new TermQuery(new Term(FIELD, "qq")), BooleanClause.Occur.MUST);
innerQuery.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.SHOULD);
- outerQuery.add(innerQuery, BooleanClause.Occur.SHOULD);
+ outerQuery.add(innerQuery.build(), BooleanClause.Occur.SHOULD);
- qtest(outerQuery, new int[] { 0,1,2,3 });
+ qtest(outerQuery.build(), new int[] { 0,1,2,3 });
}
public void testBQ6() throws Exception {
- BooleanQuery outerQuery = new BooleanQuery();
+ BooleanQuery.Builder outerQuery = new BooleanQuery.Builder();
outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
- BooleanQuery innerQuery = new BooleanQuery();
+ BooleanQuery.Builder innerQuery = new BooleanQuery.Builder();
innerQuery.add(new TermQuery(new Term(FIELD, "qq")), BooleanClause.Occur.MUST_NOT);
innerQuery.add(new TermQuery(new Term(FIELD, "w5")), BooleanClause.Occur.SHOULD);
- outerQuery.add(innerQuery, BooleanClause.Occur.MUST_NOT);
+ outerQuery.add(innerQuery.build(), BooleanClause.Occur.MUST_NOT);
- qtest(outerQuery, new int[] { 1,2,3 });
+ qtest(outerQuery.build(), new int[] { 1,2,3 });
}
public void testBQ7() throws Exception {
- BooleanQuery outerQuery = new BooleanQuery();
+ BooleanQuery.Builder outerQuery = new BooleanQuery.Builder();
outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);
- BooleanQuery innerQuery = new BooleanQuery();
+ BooleanQuery.Builder innerQuery = new BooleanQuery.Builder();
innerQuery.add(new TermQuery(new Term(FIELD, "qq")), BooleanClause.Occur.SHOULD);
- BooleanQuery childLeft = new BooleanQuery();
+ BooleanQuery.Builder childLeft = new BooleanQuery.Builder();
childLeft.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.SHOULD);
childLeft.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.MUST_NOT);
- innerQuery.add(childLeft, BooleanClause.Occur.SHOULD);
+ innerQuery.add(childLeft.build(), BooleanClause.Occur.SHOULD);
- BooleanQuery childRight = new BooleanQuery();
+ BooleanQuery.Builder childRight = new BooleanQuery.Builder();
childRight.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.MUST);
childRight.add(new TermQuery(new Term(FIELD, "w4")), BooleanClause.Occur.MUST);
- innerQuery.add(childRight, BooleanClause.Occur.SHOULD);
+ innerQuery.add(childRight.build(), BooleanClause.Occur.SHOULD);
- outerQuery.add(innerQuery, BooleanClause.Occur.MUST);
+ outerQuery.add(innerQuery.build(), BooleanClause.Occur.MUST);
- qtest(outerQuery, new int[] { 0 });
+ qtest(outerQuery.build(), new int[] { 0 });
}
public void testBQ8() throws Exception {
- BooleanQuery outerQuery = new BooleanQuery();
+ BooleanQuery.Builder outerQuery = new BooleanQuery.Builder();
outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);
- BooleanQuery innerQuery = new BooleanQuery();
+ BooleanQuery.Builder innerQuery = new BooleanQuery.Builder();
innerQuery.add(new TermQuery(new Term(FIELD, "qq")), BooleanClause.Occur.SHOULD);
- BooleanQuery childLeft = new BooleanQuery();
+ BooleanQuery.Builder childLeft = new BooleanQuery.Builder();
childLeft.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.SHOULD);
childLeft.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.MUST_NOT);
- innerQuery.add(childLeft, BooleanClause.Occur.SHOULD);
+ innerQuery.add(childLeft.build(), BooleanClause.Occur.SHOULD);
- BooleanQuery childRight = new BooleanQuery();
+ BooleanQuery.Builder childRight = new BooleanQuery.Builder();
childRight.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.MUST);
childRight.add(new TermQuery(new Term(FIELD, "w4")), BooleanClause.Occur.MUST);
- innerQuery.add(childRight, BooleanClause.Occur.SHOULD);
+ innerQuery.add(childRight.build(), BooleanClause.Occur.SHOULD);
- outerQuery.add(innerQuery, BooleanClause.Occur.SHOULD);
+ outerQuery.add(innerQuery.build(), BooleanClause.Occur.SHOULD);
- qtest(outerQuery, new int[] { 0,1,2,3 });
+ qtest(outerQuery.build(), new int[] { 0,1,2,3 });
}
public void testBQ9() throws Exception {
- BooleanQuery outerQuery = new BooleanQuery();
+ BooleanQuery.Builder outerQuery = new BooleanQuery.Builder();
outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);
- BooleanQuery innerQuery = new BooleanQuery();
+ BooleanQuery.Builder innerQuery = new BooleanQuery.Builder();
innerQuery.add(new TermQuery(new Term(FIELD, "qq")), BooleanClause.Occur.SHOULD);
- BooleanQuery childLeft = new BooleanQuery();
+ BooleanQuery.Builder childLeft = new BooleanQuery.Builder();
childLeft.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
childLeft.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.SHOULD);
- innerQuery.add(childLeft, BooleanClause.Occur.SHOULD);
+ innerQuery.add(childLeft.build(), BooleanClause.Occur.SHOULD);
- BooleanQuery childRight = new BooleanQuery();
+ BooleanQuery.Builder childRight = new BooleanQuery.Builder();
childRight.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.MUST);
childRight.add(new TermQuery(new Term(FIELD, "w4")), BooleanClause.Occur.MUST);
- innerQuery.add(childRight, BooleanClause.Occur.MUST_NOT);
+ innerQuery.add(childRight.build(), BooleanClause.Occur.MUST_NOT);
- outerQuery.add(innerQuery, BooleanClause.Occur.SHOULD);
+ outerQuery.add(innerQuery.build(), BooleanClause.Occur.SHOULD);
- qtest(outerQuery, new int[] { 0,1,2,3 });
+ qtest(outerQuery.build(), new int[] { 0,1,2,3 });
}
public void testBQ10() throws Exception {
- BooleanQuery outerQuery = new BooleanQuery();
+ BooleanQuery.Builder outerQuery = new BooleanQuery.Builder();
outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);
- BooleanQuery innerQuery = new BooleanQuery();
+ BooleanQuery.Builder innerQuery = new BooleanQuery.Builder();
innerQuery.add(new TermQuery(new Term(FIELD, "qq")), BooleanClause.Occur.SHOULD);
- BooleanQuery childLeft = new BooleanQuery();
+ BooleanQuery.Builder childLeft = new BooleanQuery.Builder();
childLeft.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
childLeft.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.SHOULD);
- innerQuery.add(childLeft, BooleanClause.Occur.SHOULD);
+ innerQuery.add(childLeft.build(), BooleanClause.Occur.SHOULD);
- BooleanQuery childRight = new BooleanQuery();
+ BooleanQuery.Builder childRight = new BooleanQuery.Builder();
childRight.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.MUST);
childRight.add(new TermQuery(new Term(FIELD, "w4")), BooleanClause.Occur.MUST);
- innerQuery.add(childRight, BooleanClause.Occur.MUST_NOT);
+ innerQuery.add(childRight.build(), BooleanClause.Occur.MUST_NOT);
- outerQuery.add(innerQuery, BooleanClause.Occur.MUST);
+ outerQuery.add(innerQuery.build(), BooleanClause.Occur.MUST);
- qtest(outerQuery, new int[] { 1 });
+ qtest(outerQuery.build(), new int[] { 1 });
}
public void testBQ11() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
TermQuery boostedQuery = new TermQuery(new Term(FIELD, "w1"));
boostedQuery.setBoost(1000);
query.add(boostedQuery, BooleanClause.Occur.SHOULD);
- qtest(query, new int[] { 0,1,2,3 });
+ qtest(query.build(), new int[] { 0,1,2,3 });
}
public void testBQ14() throws Exception {
- BooleanQuery q = new BooleanQuery(true);
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
+ q.setDisableCoord(true);
q.add(new TermQuery(new Term(FIELD, "QQQQQ")), BooleanClause.Occur.SHOULD);
q.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
- qtest(q, new int[] { 0,1,2,3 });
+ qtest(q.build(), new int[] { 0,1,2,3 });
}
public void testBQ15() throws Exception {
- BooleanQuery q = new BooleanQuery(true);
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
+ q.setDisableCoord(true);
q.add(new TermQuery(new Term(FIELD, "QQQQQ")), BooleanClause.Occur.MUST_NOT);
q.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
- qtest(q, new int[] { 0,1,2,3 });
+ qtest(q.build(), new int[] { 0,1,2,3 });
}
public void testBQ16() throws Exception {
- BooleanQuery q = new BooleanQuery(true);
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
+ q.setDisableCoord(true);
q.add(new TermQuery(new Term(FIELD, "QQQQQ")), BooleanClause.Occur.SHOULD);
- BooleanQuery booleanQuery = new BooleanQuery();
+ BooleanQuery.Builder booleanQuery = new BooleanQuery.Builder();
booleanQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
booleanQuery.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
- q.add(booleanQuery, BooleanClause.Occur.SHOULD);
- qtest(q, new int[] { 0,1 });
+ q.add(booleanQuery.build(), BooleanClause.Occur.SHOULD);
+ qtest(q.build(), new int[] { 0,1 });
}
public void testBQ17() throws Exception {
- BooleanQuery q = new BooleanQuery(true);
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
+ q.setDisableCoord(true);
q.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.SHOULD);
- BooleanQuery booleanQuery = new BooleanQuery();
+ BooleanQuery.Builder booleanQuery = new BooleanQuery.Builder();
booleanQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
booleanQuery.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
- q.add(booleanQuery, BooleanClause.Occur.SHOULD);
- qtest(q, new int[] { 0,1,2,3 });
+ q.add(booleanQuery.build(), BooleanClause.Occur.SHOULD);
+ qtest(q.build(), new int[] { 0,1,2,3 });
}
public void testBQ19() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.MUST_NOT);
query.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.SHOULD);
- qtest(query, new int[] { 0,1 });
+ qtest(query.build(), new int[] { 0,1 });
}
public void testBQ20() throws Exception {
- BooleanQuery q = new BooleanQuery();
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
q.setMinimumNumberShouldMatch(2);
q.add(new TermQuery(new Term(FIELD, "QQQQQ")), BooleanClause.Occur.SHOULD);
q.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.SHOULD);
@@ -460,183 +464,183 @@ public class TestSimpleExplanations exte
q.add(new TermQuery(new Term(FIELD, "w5")), BooleanClause.Occur.SHOULD);
q.add(new TermQuery(new Term(FIELD, "w4")), BooleanClause.Occur.SHOULD);
- qtest(q, new int[] { 0,3 });
+ qtest(q.build(), new int[] { 0,3 });
}
public void testBQ23() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.FILTER);
query.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.FILTER);
- qtest(query, new int[] { 0,1,2,3 });
+ qtest(query.build(), new int[] { 0,1,2,3 });
}
public void testBQ24() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.FILTER);
query.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.SHOULD);
- qtest(query, new int[] { 0,1,2,3 });
+ qtest(query.build(), new int[] { 0,1,2,3 });
}
public void testBQ25() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.FILTER);
query.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.MUST);
- qtest(query, new int[] { 0,1,2,3 });
+ qtest(query.build(), new int[] { 0,1,2,3 });
}
public void testBQ26() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.FILTER);
query.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
- qtest(query, new int[] { 0,1 });
+ qtest(query.build(), new int[] { 0,1 });
}
/* BQ of TQ: using alt so some fields have zero boost and some don't */
public void testMultiFieldBQ1() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);
query.add(new TermQuery(new Term(ALTFIELD, "w2")), BooleanClause.Occur.MUST);
- qtest(query, new int[] { 0,1,2,3 });
+ qtest(query.build(), new int[] { 0,1,2,3 });
}
public void testMultiFieldBQ2() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.MUST);
query.add(new TermQuery(new Term(ALTFIELD, "w3")), BooleanClause.Occur.MUST);
- qtest(query, new int[] { 2,3 });
+ qtest(query.build(), new int[] { 2,3 });
}
public void testMultiFieldBQ3() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.SHOULD);
query.add(new TermQuery(new Term(ALTFIELD, "w3")), BooleanClause.Occur.MUST);
- qtest(query, new int[] { 0,1,2,3 });
+ qtest(query.build(), new int[] { 0,1,2,3 });
}
public void testMultiFieldBQ4() throws Exception {
- BooleanQuery outerQuery = new BooleanQuery();
+ BooleanQuery.Builder outerQuery = new BooleanQuery.Builder();
outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
- BooleanQuery innerQuery = new BooleanQuery();
+ BooleanQuery.Builder innerQuery = new BooleanQuery.Builder();
innerQuery.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
innerQuery.add(new TermQuery(new Term(ALTFIELD, "w2")), BooleanClause.Occur.SHOULD);
- outerQuery.add(innerQuery, BooleanClause.Occur.SHOULD);
+ outerQuery.add(innerQuery.build(), BooleanClause.Occur.SHOULD);
- qtest(outerQuery, new int[] { 0,1,2,3 });
+ qtest(outerQuery.build(), new int[] { 0,1,2,3 });
}
public void testMultiFieldBQ5() throws Exception {
- BooleanQuery outerQuery = new BooleanQuery();
+ BooleanQuery.Builder outerQuery = new BooleanQuery.Builder();
outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
- BooleanQuery innerQuery = new BooleanQuery();
+ BooleanQuery.Builder innerQuery = new BooleanQuery.Builder();
innerQuery.add(new TermQuery(new Term(ALTFIELD, "qq")), BooleanClause.Occur.MUST);
innerQuery.add(new TermQuery(new Term(ALTFIELD, "w2")), BooleanClause.Occur.SHOULD);
- outerQuery.add(innerQuery, BooleanClause.Occur.SHOULD);
+ outerQuery.add(innerQuery.build(), BooleanClause.Occur.SHOULD);
- qtest(outerQuery, new int[] { 0,1,2,3 });
+ qtest(outerQuery.build(), new int[] { 0,1,2,3 });
}
public void testMultiFieldBQ6() throws Exception {
- BooleanQuery outerQuery = new BooleanQuery();
+ BooleanQuery.Builder outerQuery = new BooleanQuery.Builder();
outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
- BooleanQuery innerQuery = new BooleanQuery();
+ BooleanQuery.Builder innerQuery = new BooleanQuery.Builder();
innerQuery.add(new TermQuery(new Term(ALTFIELD, "qq")), BooleanClause.Occur.MUST_NOT);
innerQuery.add(new TermQuery(new Term(ALTFIELD, "w5")), BooleanClause.Occur.SHOULD);
- outerQuery.add(innerQuery, BooleanClause.Occur.MUST_NOT);
+ outerQuery.add(innerQuery.build(), BooleanClause.Occur.MUST_NOT);
- qtest(outerQuery, new int[] { 1,2,3 });
+ qtest(outerQuery.build(), new int[] { 1,2,3 });
}
public void testMultiFieldBQ7() throws Exception {
- BooleanQuery outerQuery = new BooleanQuery();
+ BooleanQuery.Builder outerQuery = new BooleanQuery.Builder();
outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);
- BooleanQuery innerQuery = new BooleanQuery();
+ BooleanQuery.Builder innerQuery = new BooleanQuery.Builder();
innerQuery.add(new TermQuery(new Term(ALTFIELD, "qq")), BooleanClause.Occur.SHOULD);
- BooleanQuery childLeft = new BooleanQuery();
+ BooleanQuery.Builder childLeft = new BooleanQuery.Builder();
childLeft.add(new TermQuery(new Term(ALTFIELD, "xx")), BooleanClause.Occur.SHOULD);
childLeft.add(new TermQuery(new Term(ALTFIELD, "w2")), BooleanClause.Occur.MUST_NOT);
- innerQuery.add(childLeft, BooleanClause.Occur.SHOULD);
+ innerQuery.add(childLeft.build(), BooleanClause.Occur.SHOULD);
- BooleanQuery childRight = new BooleanQuery();
+ BooleanQuery.Builder childRight = new BooleanQuery.Builder();
childRight.add(new TermQuery(new Term(ALTFIELD, "w3")), BooleanClause.Occur.MUST);
childRight.add(new TermQuery(new Term(ALTFIELD, "w4")), BooleanClause.Occur.MUST);
- innerQuery.add(childRight, BooleanClause.Occur.SHOULD);
+ innerQuery.add(childRight.build(), BooleanClause.Occur.SHOULD);
- outerQuery.add(innerQuery, BooleanClause.Occur.MUST);
+ outerQuery.add(innerQuery.build(), BooleanClause.Occur.MUST);
- qtest(outerQuery, new int[] { 0 });
+ qtest(outerQuery.build(), new int[] { 0 });
}
public void testMultiFieldBQ8() throws Exception {
- BooleanQuery outerQuery = new BooleanQuery();
+ BooleanQuery.Builder outerQuery = new BooleanQuery.Builder();
outerQuery.add(new TermQuery(new Term(ALTFIELD, "w1")), BooleanClause.Occur.MUST);
- BooleanQuery innerQuery = new BooleanQuery();
+ BooleanQuery.Builder innerQuery = new BooleanQuery.Builder();
innerQuery.add(new TermQuery(new Term(FIELD, "qq")), BooleanClause.Occur.SHOULD);
- BooleanQuery childLeft = new BooleanQuery();
+ BooleanQuery.Builder childLeft = new BooleanQuery.Builder();
childLeft.add(new TermQuery(new Term(ALTFIELD, "xx")), BooleanClause.Occur.SHOULD);
childLeft.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.MUST_NOT);
- innerQuery.add(childLeft, BooleanClause.Occur.SHOULD);
+ innerQuery.add(childLeft.build(), BooleanClause.Occur.SHOULD);
- BooleanQuery childRight = new BooleanQuery();
+ BooleanQuery.Builder childRight = new BooleanQuery.Builder();
childRight.add(new TermQuery(new Term(ALTFIELD, "w3")), BooleanClause.Occur.MUST);
childRight.add(new TermQuery(new Term(FIELD, "w4")), BooleanClause.Occur.MUST);
- innerQuery.add(childRight, BooleanClause.Occur.SHOULD);
+ innerQuery.add(childRight.build(), BooleanClause.Occur.SHOULD);
- outerQuery.add(innerQuery, BooleanClause.Occur.SHOULD);
+ outerQuery.add(innerQuery.build(), BooleanClause.Occur.SHOULD);
- qtest(outerQuery, new int[] { 0,1,2,3 });
+ qtest(outerQuery.build(), new int[] { 0,1,2,3 });
}
public void testMultiFieldBQ9() throws Exception {
- BooleanQuery outerQuery = new BooleanQuery();
+ BooleanQuery.Builder outerQuery = new BooleanQuery.Builder();
outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);
- BooleanQuery innerQuery = new BooleanQuery();
+ BooleanQuery.Builder innerQuery = new BooleanQuery.Builder();
innerQuery.add(new TermQuery(new Term(ALTFIELD, "qq")), BooleanClause.Occur.SHOULD);
- BooleanQuery childLeft = new BooleanQuery();
+ BooleanQuery.Builder childLeft = new BooleanQuery.Builder();
childLeft.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
childLeft.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.SHOULD);
- innerQuery.add(childLeft, BooleanClause.Occur.SHOULD);
+ innerQuery.add(childLeft.build(), BooleanClause.Occur.SHOULD);
- BooleanQuery childRight = new BooleanQuery();
+ BooleanQuery.Builder childRight = new BooleanQuery.Builder();
childRight.add(new TermQuery(new Term(ALTFIELD, "w3")), BooleanClause.Occur.MUST);
childRight.add(new TermQuery(new Term(FIELD, "w4")), BooleanClause.Occur.MUST);
- innerQuery.add(childRight, BooleanClause.Occur.MUST_NOT);
+ innerQuery.add(childRight.build(), BooleanClause.Occur.MUST_NOT);
- outerQuery.add(innerQuery, BooleanClause.Occur.SHOULD);
+ outerQuery.add(innerQuery.build(), BooleanClause.Occur.SHOULD);
- qtest(outerQuery, new int[] { 0,1,2,3 });
+ qtest(outerQuery.build(), new int[] { 0,1,2,3 });
}
public void testMultiFieldBQ10() throws Exception {
- BooleanQuery outerQuery = new BooleanQuery();
+ BooleanQuery.Builder outerQuery = new BooleanQuery.Builder();
outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);
- BooleanQuery innerQuery = new BooleanQuery();
+ BooleanQuery.Builder innerQuery = new BooleanQuery.Builder();
innerQuery.add(new TermQuery(new Term(ALTFIELD, "qq")), BooleanClause.Occur.SHOULD);
- BooleanQuery childLeft = new BooleanQuery();
+ BooleanQuery.Builder childLeft = new BooleanQuery.Builder();
childLeft.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
childLeft.add(new TermQuery(new Term(ALTFIELD, "w2")), BooleanClause.Occur.SHOULD);
- innerQuery.add(childLeft, BooleanClause.Occur.SHOULD);
+ innerQuery.add(childLeft.build(), BooleanClause.Occur.SHOULD);
- BooleanQuery childRight = new BooleanQuery();
+ BooleanQuery.Builder childRight = new BooleanQuery.Builder();
childRight.add(new TermQuery(new Term(ALTFIELD, "w3")), BooleanClause.Occur.MUST);
childRight.add(new TermQuery(new Term(FIELD, "w4")), BooleanClause.Occur.MUST);
- innerQuery.add(childRight, BooleanClause.Occur.MUST_NOT);
+ innerQuery.add(childRight.build(), BooleanClause.Occur.MUST_NOT);
- outerQuery.add(innerQuery, BooleanClause.Occur.MUST);
+ outerQuery.add(innerQuery.build(), BooleanClause.Occur.MUST);
- qtest(outerQuery, new int[] { 1 });
+ qtest(outerQuery.build(), new int[] { 1 });
}
/* BQ of PQ: using alt so some fields have zero boost and some don't */
public void testMultiFieldBQofPQ1() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
PhraseQuery leftChild = new PhraseQuery(FIELD, "w1", "w2");
query.add(leftChild, BooleanClause.Occur.SHOULD);
@@ -644,10 +648,10 @@ public class TestSimpleExplanations exte
PhraseQuery rightChild = new PhraseQuery(ALTFIELD, "w1", "w2");
query.add(rightChild, BooleanClause.Occur.SHOULD);
- qtest(query, new int[] { 0 });
+ qtest(query.build(), new int[] { 0 });
}
public void testMultiFieldBQofPQ2() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
PhraseQuery leftChild = new PhraseQuery(FIELD, "w1", "w3");
query.add(leftChild, BooleanClause.Occur.SHOULD);
@@ -655,10 +659,10 @@ public class TestSimpleExplanations exte
PhraseQuery rightChild = new PhraseQuery(ALTFIELD, "w1", "w3");
query.add(rightChild, BooleanClause.Occur.SHOULD);
- qtest(query, new int[] { 1,3 });
+ qtest(query.build(), new int[] { 1,3 });
}
public void testMultiFieldBQofPQ3() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
PhraseQuery leftChild = new PhraseQuery(1, FIELD, "w1", "w2");
query.add(leftChild, BooleanClause.Occur.SHOULD);
@@ -666,10 +670,10 @@ public class TestSimpleExplanations exte
PhraseQuery rightChild = new PhraseQuery(1, ALTFIELD, "w1", "w2");
query.add(rightChild, BooleanClause.Occur.SHOULD);
- qtest(query, new int[] { 0,1,2 });
+ qtest(query.build(), new int[] { 0,1,2 });
}
public void testMultiFieldBQofPQ4() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
PhraseQuery leftChild = new PhraseQuery(1, FIELD, "w2", "w3");
query.add(leftChild, BooleanClause.Occur.SHOULD);
@@ -677,10 +681,10 @@ public class TestSimpleExplanations exte
PhraseQuery rightChild = new PhraseQuery(1, ALTFIELD, "w2", "w3");
query.add(rightChild, BooleanClause.Occur.SHOULD);
- qtest(query, new int[] { 0,1,2,3 });
+ qtest(query.build(), new int[] { 0,1,2,3 });
}
public void testMultiFieldBQofPQ5() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
PhraseQuery leftChild = new PhraseQuery(1, FIELD, "w3", "w2");
query.add(leftChild, BooleanClause.Occur.SHOULD);
@@ -688,10 +692,10 @@ public class TestSimpleExplanations exte
PhraseQuery rightChild = new PhraseQuery(1, ALTFIELD, "w3", "w2");
query.add(rightChild, BooleanClause.Occur.SHOULD);
- qtest(query, new int[] { 1,3 });
+ qtest(query.build(), new int[] { 1,3 });
}
public void testMultiFieldBQofPQ6() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
PhraseQuery leftChild = new PhraseQuery(2, FIELD, "w3", "w2");
query.add(leftChild, BooleanClause.Occur.SHOULD);
@@ -699,10 +703,10 @@ public class TestSimpleExplanations exte
PhraseQuery rightChild = new PhraseQuery(2, ALTFIELD, "w3", "w2");
query.add(rightChild, BooleanClause.Occur.SHOULD);
- qtest(query, new int[] { 0,1,3 });
+ qtest(query.build(), new int[] { 0,1,3 });
}
public void testMultiFieldBQofPQ7() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
PhraseQuery leftChild = new PhraseQuery(3, FIELD, "w3", "w2");
query.add(leftChild, BooleanClause.Occur.SHOULD);
@@ -710,7 +714,7 @@ public class TestSimpleExplanations exte
PhraseQuery rightChild = new PhraseQuery(1, ALTFIELD, "w3", "w2");
query.add(rightChild, BooleanClause.Occur.SHOULD);
- qtest(query, new int[] { 0,1,2,3 });
+ qtest(query.build(), new int[] { 0,1,2,3 });
}
}
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSimpleSearchEquivalence.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSimpleSearchEquivalence.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSimpleSearchEquivalence.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSimpleSearchEquivalence.java Thu Jun 18 07:14:05 2015
@@ -34,10 +34,10 @@ public class TestSimpleSearchEquivalence
Term t1 = randomTerm();
Term t2 = randomTerm();
TermQuery q1 = new TermQuery(t1);
- BooleanQuery q2 = new BooleanQuery();
+ BooleanQuery.Builder q2 = new BooleanQuery.Builder();
q2.add(new TermQuery(t1), Occur.SHOULD);
q2.add(new TermQuery(t2), Occur.SHOULD);
- assertSubsetOf(q1, q2);
+ assertSubsetOf(q1, q2.build());
}
/** A â (+A B) */
@@ -45,47 +45,47 @@ public class TestSimpleSearchEquivalence
Term t1 = randomTerm();
Term t2 = randomTerm();
TermQuery q1 = new TermQuery(t1);
- BooleanQuery q2 = new BooleanQuery();
+ BooleanQuery.Builder q2 = new BooleanQuery.Builder();
q2.add(new TermQuery(t1), Occur.MUST);
q2.add(new TermQuery(t2), Occur.SHOULD);
- assertSubsetOf(q1, q2);
+ assertSubsetOf(q1, q2.build());
}
/** (A -B) â A */
public void testBooleanReqExclVersusTerm() throws Exception {
Term t1 = randomTerm();
Term t2 = randomTerm();
- BooleanQuery q1 = new BooleanQuery();
+ BooleanQuery.Builder q1 = new BooleanQuery.Builder();
q1.add(new TermQuery(t1), Occur.MUST);
q1.add(new TermQuery(t2), Occur.MUST_NOT);
TermQuery q2 = new TermQuery(t1);
- assertSubsetOf(q1, q2);
+ assertSubsetOf(q1.build(), q2);
}
/** (+A +B) â (A B) */
public void testBooleanAndVersusBooleanOr() throws Exception {
Term t1 = randomTerm();
Term t2 = randomTerm();
- BooleanQuery q1 = new BooleanQuery();
+ BooleanQuery.Builder q1 = new BooleanQuery.Builder();
q1.add(new TermQuery(t1), Occur.SHOULD);
q1.add(new TermQuery(t2), Occur.SHOULD);
- BooleanQuery q2 = new BooleanQuery();
+ BooleanQuery.Builder q2 = new BooleanQuery.Builder();
q2.add(new TermQuery(t1), Occur.SHOULD);
q2.add(new TermQuery(t2), Occur.SHOULD);
- assertSubsetOf(q1, q2);
+ assertSubsetOf(q1.build(), q2.build());
}
/** (A B) = (A | B) */
public void testDisjunctionSumVersusDisjunctionMax() throws Exception {
Term t1 = randomTerm();
Term t2 = randomTerm();
- BooleanQuery q1 = new BooleanQuery();
+ BooleanQuery.Builder q1 = new BooleanQuery.Builder();
q1.add(new TermQuery(t1), Occur.SHOULD);
q1.add(new TermQuery(t2), Occur.SHOULD);
DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.5f);
q2.add(new TermQuery(t1));
q2.add(new TermQuery(t2));
- assertSameSet(q1, q2);
+ assertSameSet(q1.build(), q2);
}
/** "A B" â (+A +B) */
@@ -93,10 +93,10 @@ public class TestSimpleSearchEquivalence
Term t1 = randomTerm();
Term t2 = randomTerm();
PhraseQuery q1 = new PhraseQuery(t1.field(), t1.bytes(), t2.bytes());
- BooleanQuery q2 = new BooleanQuery();
+ BooleanQuery.Builder q2 = new BooleanQuery.Builder();
q2.add(new TermQuery(t1), Occur.MUST);
q2.add(new TermQuery(t2), Occur.MUST);
- assertSubsetOf(q1, q2);
+ assertSubsetOf(q1, q2.build());
}
/** same as above, with posincs */
@@ -107,10 +107,10 @@ public class TestSimpleSearchEquivalence
builder.add(t1, 0);
builder.add(t2, 2);
PhraseQuery q1 = builder.build();
- BooleanQuery q2 = new BooleanQuery();
+ BooleanQuery.Builder q2 = new BooleanQuery.Builder();
q2.add(new TermQuery(t1), Occur.MUST);
q2.add(new TermQuery(t2), Occur.MUST);
- assertSubsetOf(q1, q2);
+ assertSubsetOf(q1, q2.build());
}
/** "A B" â "A B"~1 */
@@ -172,10 +172,10 @@ public class TestSimpleSearchEquivalence
t2 = randomTerm();
} while (t1.equals(t2));
PhraseQuery q1 = new PhraseQuery(Integer.MAX_VALUE, t1.field(), t1.bytes(), t2.bytes());
- BooleanQuery q2 = new BooleanQuery();
+ BooleanQuery.Builder q2 = new BooleanQuery.Builder();
q2.add(new TermQuery(t1), Occur.MUST);
q2.add(new TermQuery(t2), Occur.MUST);
- assertSameSet(q1, q2);
+ assertSameSet(q1, q2.build());
}
/** Phrase positions are relative. */
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSortRandom.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSortRandom.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSortRandom.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSortRandom.java Thu Jun 18 07:14:05 2015
@@ -133,7 +133,6 @@ public class TestSortRandom extends Luce
final TopFieldDocs hits;
final SortField sf;
final boolean sortMissingLast;
- final boolean missingIsNull;
sf = new SortField("stringdv", type, reverse);
sortMissingLast = random().nextBoolean();
@@ -152,14 +151,14 @@ public class TestSortRandom extends Luce
int queryType = random.nextInt(2);
if (queryType == 0) {
// force out of order
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
// Add a Query with SHOULD, since bw.scorer() returns BooleanScorer2
// which delegates to BS if there are no mandatory clauses.
bq.add(new MatchAllDocsQuery(), Occur.SHOULD);
// Set minNrShouldMatch to 1 so that BQ will not optimize rewrite to return
// the clause instead of BQ.
bq.setMinimumNumberShouldMatch(1);
- hits = s.search(new FilteredQuery(bq, f), hitCount, sort, random.nextBoolean(), random.nextBoolean());
+ hits = s.search(new FilteredQuery(bq.build(), f), hitCount, sort, random.nextBoolean(), random.nextBoolean());
} else {
hits = s.search(new ConstantScoreQuery(f),
hitCount, sort, random.nextBoolean(), random.nextBoolean());
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSubScorerFreqs.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSubScorerFreqs.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSubScorerFreqs.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestSubScorerFreqs.java Thu Jun 18 07:14:05 2015
@@ -145,12 +145,12 @@ public class TestSubScorerFreqs extends
TermQuery cQuery = new TermQuery(new Term("f", "c"));
TermQuery yQuery = new TermQuery(new Term("f", "y"));
- BooleanQuery query = new BooleanQuery();
- BooleanQuery inner = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
+ BooleanQuery.Builder inner = new BooleanQuery.Builder();
inner.add(cQuery, Occur.SHOULD);
inner.add(yQuery, Occur.MUST_NOT);
- query.add(inner, Occur.MUST);
+ query.add(inner.build(), Occur.MUST);
query.add(aQuery, Occur.MUST);
query.add(dQuery, Occur.MUST);
@@ -164,7 +164,7 @@ public class TestSubScorerFreqs extends
for (final Set<String> occur : occurList) {
CountingCollector c = new CountingCollector(TopScoreDocCollector.create(
10), occur);
- s.search(query, c);
+ s.search(query.build(), c);
final int maxDocs = s.getIndexReader().maxDoc();
assertEquals(maxDocs, c.docCounts.size());
boolean includeOptional = occur.contains("SHOULD");
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java Thu Jun 18 07:14:05 2015
@@ -92,7 +92,7 @@ public class TestTimeLimitingCollector e
iw.close();
searcher = newSearcher(reader);
- BooleanQuery booleanQuery = new BooleanQuery();
+ BooleanQuery.Builder booleanQuery = new BooleanQuery.Builder();
booleanQuery.add(new TermQuery(new Term(FIELD_NAME, "one")), BooleanClause.Occur.SHOULD);
// start from 1, so that the 0th doc never matches
for (int i = 1; i < docText.length; i++) {
@@ -102,7 +102,7 @@ public class TestTimeLimitingCollector e
}
}
- query = booleanQuery;
+ query = booleanQuery.build();
// warm the searcher
searcher.search(query, 1000);
@@ -274,10 +274,10 @@ public class TestTimeLimitingCollector e
// search
TimeExceededException timoutException = null;
try {
- BooleanQuery booleanQuery = new BooleanQuery(); // won't match - we only test if we check timeout when collectors are pulled
+ BooleanQuery.Builder booleanQuery = new BooleanQuery.Builder(); // won't match - we only test if we check timeout when collectors are pulled
booleanQuery.add(new TermQuery(new Term(FIELD_NAME, "one")), BooleanClause.Occur.MUST);
booleanQuery.add(new TermQuery(new Term(FIELD_NAME, "blueberry")), BooleanClause.Occur.MUST);
- searcher.search(booleanQuery, collector);
+ searcher.search(booleanQuery.build(), collector);
} catch (TimeExceededException x) {
timoutException = x;
}
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java Thu Jun 18 07:14:05 2015
@@ -144,10 +144,10 @@ public class TestWildcard extends Lucene
Query query4 = new WildcardQuery(new Term("body", "m*tal*"));
Query query5 = new WildcardQuery(new Term("body", "m*tals"));
- BooleanQuery query6 = new BooleanQuery();
+ BooleanQuery.Builder query6 = new BooleanQuery.Builder();
query6.add(query5, BooleanClause.Occur.SHOULD);
- BooleanQuery query7 = new BooleanQuery();
+ BooleanQuery.Builder query7 = new BooleanQuery.Builder();
query7.add(query3, BooleanClause.Occur.SHOULD);
query7.add(query5, BooleanClause.Occur.SHOULD);
@@ -159,8 +159,8 @@ public class TestWildcard extends Lucene
assertMatches(searcher, query3, 1);
assertMatches(searcher, query4, 2);
assertMatches(searcher, query5, 1);
- assertMatches(searcher, query6, 1);
- assertMatches(searcher, query7, 2);
+ assertMatches(searcher, query6.build(), 1);
+ assertMatches(searcher, query7.build(), 2);
assertMatches(searcher, query8, 0);
assertMatches(searcher, new WildcardQuery(new Term("body", "*tall")), 0);
assertMatches(searcher, new WildcardQuery(new Term("body", "*tal")), 1);
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/payloads/TestPayloadTermQuery.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/payloads/TestPayloadTermQuery.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/payloads/TestPayloadTermQuery.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/payloads/TestPayloadTermQuery.java Thu Jun 18 07:14:05 2015
@@ -288,15 +288,15 @@ public class TestPayloadTermQuery extend
new MaxPayloadFunction());
BooleanClause c1 = new BooleanClause(q1, BooleanClause.Occur.MUST);
BooleanClause c2 = new BooleanClause(q2, BooleanClause.Occur.MUST_NOT);
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(c1);
query.add(c2);
- TopDocs hits = searcher.search(query, 100);
+ TopDocs hits = searcher.search(query.build(), 100);
assertTrue("hits is null and it shouldn't be", hits != null);
assertTrue("hits Size: " + hits.totalHits + " is not: " + 1, hits.totalHits == 1);
int[] results = new int[1];
results[0] = 0;//hits.scoreDocs[0].doc;
- CheckHits.checkHitCollector(random(), query, PayloadHelper.NO_PAYLOAD_FIELD, searcher, results);
+ CheckHits.checkHitCollector(random(), query.build(), PayloadHelper.NO_PAYLOAD_FIELD, searcher, results);
}
static class BoostingSimilarity extends DefaultSimilarity {
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/similarities/TestSimilarity2.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/similarities/TestSimilarity2.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/similarities/TestSimilarity2.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/similarities/TestSimilarity2.java Thu Jun 18 07:14:05 2015
@@ -102,10 +102,11 @@ public class TestSimilarity2 extends Luc
for (Similarity sim : sims) {
is.setSimilarity(sim);
- BooleanQuery query = new BooleanQuery(true);
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
+ query.setDisableCoord(true);
query.add(new TermQuery(new Term("foo", "bar")), BooleanClause.Occur.SHOULD);
query.add(new TermQuery(new Term("bar", "baz")), BooleanClause.Occur.SHOULD);
- assertEquals(1, is.search(query, 10).totalHits);
+ assertEquals(1, is.search(query.build(), 10).totalHits);
}
ir.close();
dir.close();
@@ -124,10 +125,11 @@ public class TestSimilarity2 extends Luc
for (Similarity sim : sims) {
is.setSimilarity(sim);
- BooleanQuery query = new BooleanQuery(true);
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
+ query.setDisableCoord(true);
query.add(new TermQuery(new Term("foo", "bar")), BooleanClause.Occur.SHOULD);
query.add(new TermQuery(new Term("foo", "baz")), BooleanClause.Occur.SHOULD);
- assertEquals(1, is.search(query, 10).totalHits);
+ assertEquals(1, is.search(query.build(), 10).totalHits);
}
ir.close();
dir.close();
@@ -149,9 +151,10 @@ public class TestSimilarity2 extends Luc
for (Similarity sim : sims) {
is.setSimilarity(sim);
- BooleanQuery query = new BooleanQuery(true);
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
+ query.setDisableCoord(true);
query.add(new TermQuery(new Term("foo", "bar")), BooleanClause.Occur.SHOULD);
- assertEquals(1, is.search(query, 10).totalHits);
+ assertEquals(1, is.search(query.build(), 10).totalHits);
}
ir.close();
dir.close();
@@ -174,9 +177,10 @@ public class TestSimilarity2 extends Luc
for (Similarity sim : sims) {
is.setSimilarity(sim);
- BooleanQuery query = new BooleanQuery(true);
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
+ query.setDisableCoord(true);
query.add(new TermQuery(new Term("foo", "bar")), BooleanClause.Occur.SHOULD);
- assertEquals(1, is.search(query, 10).totalHits);
+ assertEquals(1, is.search(query.build(), 10).totalHits);
}
ir.close();
dir.close();
@@ -200,9 +204,10 @@ public class TestSimilarity2 extends Luc
for (Similarity sim : sims) {
is.setSimilarity(sim);
- BooleanQuery query = new BooleanQuery(true);
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
+ query.setDisableCoord(true);
query.add(new TermQuery(new Term("foo", "bar")), BooleanClause.Occur.SHOULD);
- assertEquals(1, is.search(query, 10).totalHits);
+ assertEquals(1, is.search(query.build(), 10).totalHits);
}
ir.close();
dir.close();
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestBasics.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestBasics.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestBasics.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestBasics.java Thu Jun 18 07:14:05 2015
@@ -125,10 +125,10 @@ public class TestBasics extends LuceneTe
}
public void testBoolean() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term("field", "seventy")), BooleanClause.Occur.MUST);
query.add(new TermQuery(new Term("field", "seven")), BooleanClause.Occur.MUST);
- checkHits(query, new int[]
+ checkHits(query.build(), new int[]
{77, 177, 277, 377, 477, 577, 677, 770, 771, 772, 773, 774, 775, 776, 777,
778, 779, 877, 977, 1077, 1177, 1277, 1377, 1477, 1577, 1677,
1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1877,
@@ -136,10 +136,10 @@ public class TestBasics extends LuceneTe
}
public void testBoolean2() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term("field", "sevento")), BooleanClause.Occur.MUST);
query.add(new TermQuery(new Term("field", "sevenly")), BooleanClause.Occur.MUST);
- checkHits(query, new int[] {});
+ checkHits(query.build(), new int[] {});
}
public void testSpanNearExact() throws Exception {
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestSpanSearchEquivalence.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestSpanSearchEquivalence.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestSpanSearchEquivalence.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestSpanSearchEquivalence.java Thu Jun 18 07:14:05 2015
@@ -60,11 +60,11 @@ public class TestSpanSearchEquivalence e
public void testSpanOrVersusBooleanTerm() throws Exception {
Term t1 = randomTerm();
Term t2 = randomTerm();
- BooleanQuery q1 = new BooleanQuery();
+ BooleanQuery.Builder q1 = new BooleanQuery.Builder();
q1.add(new TermQuery(t1), Occur.SHOULD);
q1.add(new TermQuery(t2), Occur.SHOULD);
SpanQuery q2 = spanQuery(new SpanOrQuery(spanQuery(new SpanTermQuery(t1)), spanQuery(new SpanTermQuery(t2))));
- assertSameSet(q1, q2);
+ assertSameSet(q1.build(), q2);
}
/** SpanOrQuery(SpanNearQuery[A B], SpanNearQuery[C D]) = (SpanNearQuery[A B], SpanNearQuery[C D]) */
@@ -81,11 +81,11 @@ public class TestSpanSearchEquivalence e
spanQuery(new SpanTermQuery(t3)),
spanQuery(new SpanTermQuery(t4))
}, 10, random().nextBoolean()));
- BooleanQuery q1 = new BooleanQuery();
+ BooleanQuery.Builder q1 = new BooleanQuery.Builder();
q1.add(near1, Occur.SHOULD);
q1.add(near2, Occur.SHOULD);
SpanQuery q2 = spanQuery(new SpanOrQuery(near1, near2));
- assertSameSet(q1, q2);
+ assertSameSet(q1.build(), q2);
}
/** SpanNotQuery(A, B) â SpanTermQuery(A) */
@@ -166,10 +166,10 @@ public class TestSpanSearchEquivalence e
spanQuery(new SpanTermQuery(t2))
};
SpanQuery q1 = spanQuery(new SpanNearQuery(subquery, Integer.MAX_VALUE, false));
- BooleanQuery q2 = new BooleanQuery();
+ BooleanQuery.Builder q2 = new BooleanQuery.Builder();
q2.add(new TermQuery(t1), Occur.MUST);
q2.add(new TermQuery(t2), Occur.MUST);
- assertSameSet(q1, q2);
+ assertSameSet(q1, q2.build());
}
/** SpanNearQuery([A B], 0, false) â SpanNearQuery([A B], 1, false) */
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestSpansAdvanced.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestSpansAdvanced.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestSpansAdvanced.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestSpansAdvanced.java Thu Jun 18 07:14:05 2015
@@ -21,7 +21,6 @@ import java.io.IOException;
import org.apache.lucene.document.Field;
import org.apache.lucene.util.LuceneTestCase;
-
import org.apache.lucene.analysis.MockAnalyzer;
import org.apache.lucene.analysis.MockTokenFilter;
import org.apache.lucene.analysis.MockTokenizer;
@@ -110,13 +109,13 @@ public class TestSpansAdvanced extends L
final float expectedScore) throws IOException {
final Query spanQuery = new SpanTermQuery(new Term(FIELD_TEXT, "work"));
- final BooleanQuery query = new BooleanQuery();
+ final BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(spanQuery, BooleanClause.Occur.MUST);
query.add(spanQuery, BooleanClause.Occur.MUST);
final String[] expectedIds = new String[] {"1", "2", "3", "4"};
final float[] expectedScores = new float[] {expectedScore, expectedScore,
expectedScore, expectedScore};
- assertHits(s, query, "two span queries", expectedIds, expectedScores);
+ assertHits(s, query.build(), "two span queries", expectedIds, expectedScores);
}
/**
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestSpansAdvanced2.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestSpansAdvanced2.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestSpansAdvanced2.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestSpansAdvanced2.java Thu Jun 18 07:14:05 2015
@@ -99,14 +99,14 @@ public class TestSpansAdvanced2 extends
final Query spanQuery1 = new SpanTermQuery(new Term(FIELD_TEXT, "should"));
final Query spanQuery2 = new SpanTermQuery(new Term(FIELD_TEXT, "we"));
- final BooleanQuery query = new BooleanQuery();
+ final BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(spanQuery1, BooleanClause.Occur.MUST);
query.add(spanQuery2, BooleanClause.Occur.MUST);
final String[] expectedIds = new String[] {"D", "A"};
// these values were pre LUCENE-413
// final float[] expectedScores = new float[] { 0.93163157f, 0.20698164f };
final float[] expectedScores = new float[] {1.0191123f, 0.93163157f};
- assertHits(searcher2, query, "multiple different span queries",
+ assertHits(searcher2, query.build(), "multiple different span queries",
expectedIds, expectedScores);
}
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/util/TestQueryBuilder.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/util/TestQueryBuilder.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/util/TestQueryBuilder.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/util/TestQueryBuilder.java Thu Jun 18 07:14:05 2015
@@ -32,6 +32,7 @@ import org.apache.lucene.search.BooleanC
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.MultiPhraseQuery;
import org.apache.lucene.search.PhraseQuery;
+import org.apache.lucene.search.Query;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.util.automaton.CharacterRunAutomaton;
import org.apache.lucene.util.automaton.RegExp;
@@ -45,19 +46,19 @@ public class TestQueryBuilder extends Lu
}
public void testBoolean() {
- BooleanQuery expected = new BooleanQuery();
+ BooleanQuery.Builder expected = new BooleanQuery.Builder();
expected.add(new TermQuery(new Term("field", "foo")), BooleanClause.Occur.SHOULD);
expected.add(new TermQuery(new Term("field", "bar")), BooleanClause.Occur.SHOULD);
QueryBuilder builder = new QueryBuilder(new MockAnalyzer(random()));
- assertEquals(expected, builder.createBooleanQuery("field", "foo bar"));
+ assertEquals(expected.build(), builder.createBooleanQuery("field", "foo bar"));
}
public void testBooleanMust() {
- BooleanQuery expected = new BooleanQuery();
+ BooleanQuery.Builder expected = new BooleanQuery.Builder();
expected.add(new TermQuery(new Term("field", "foo")), BooleanClause.Occur.MUST);
expected.add(new TermQuery(new Term("field", "bar")), BooleanClause.Occur.MUST);
QueryBuilder builder = new QueryBuilder(new MockAnalyzer(random()));
- assertEquals(expected, builder.createBooleanQuery("field", "foo bar", BooleanClause.Occur.MUST));
+ assertEquals(expected.build(), builder.createBooleanQuery("field", "foo bar", BooleanClause.Occur.MUST));
}
public void testMinShouldMatchNone() {
@@ -73,26 +74,30 @@ public class TestQueryBuilder extends Lu
}
public void testMinShouldMatch() {
- BooleanQuery expected = new BooleanQuery();
- expected.add(new TermQuery(new Term("field", "one")), BooleanClause.Occur.SHOULD);
- expected.add(new TermQuery(new Term("field", "two")), BooleanClause.Occur.SHOULD);
- expected.add(new TermQuery(new Term("field", "three")), BooleanClause.Occur.SHOULD);
- expected.add(new TermQuery(new Term("field", "four")), BooleanClause.Occur.SHOULD);
- expected.setMinimumNumberShouldMatch(0);
-
+ BooleanQuery.Builder expectedB = new BooleanQuery.Builder();
+ expectedB.add(new TermQuery(new Term("field", "one")), BooleanClause.Occur.SHOULD);
+ expectedB.add(new TermQuery(new Term("field", "two")), BooleanClause.Occur.SHOULD);
+ expectedB.add(new TermQuery(new Term("field", "three")), BooleanClause.Occur.SHOULD);
+ expectedB.add(new TermQuery(new Term("field", "four")), BooleanClause.Occur.SHOULD);
+ expectedB.setMinimumNumberShouldMatch(0);
+ Query expected = expectedB.build();
+
QueryBuilder builder = new QueryBuilder(new MockAnalyzer(random()));
- assertEquals(expected, builder.createMinShouldMatchQuery("field", "one two three four", 0.1f));
- assertEquals(expected, builder.createMinShouldMatchQuery("field", "one two three four", 0.24f));
+ //assertEquals(expected, builder.createMinShouldMatchQuery("field", "one two three four", 0.1f));
+ //assertEquals(expected, builder.createMinShouldMatchQuery("field", "one two three four", 0.24f));
- expected.setMinimumNumberShouldMatch(1);
+ expectedB.setMinimumNumberShouldMatch(1);
+ expected = expectedB.build();
assertEquals(expected, builder.createMinShouldMatchQuery("field", "one two three four", 0.25f));
assertEquals(expected, builder.createMinShouldMatchQuery("field", "one two three four", 0.49f));
- expected.setMinimumNumberShouldMatch(2);
+ expectedB.setMinimumNumberShouldMatch(2);
+ expected = expectedB.build();
assertEquals(expected, builder.createMinShouldMatchQuery("field", "one two three four", 0.5f));
assertEquals(expected, builder.createMinShouldMatchQuery("field", "one two three four", 0.74f));
- expected.setMinimumNumberShouldMatch(3);
+ expectedB.setMinimumNumberShouldMatch(3);
+ expected = expectedB.build();
assertEquals(expected, builder.createMinShouldMatchQuery("field", "one two three four", 0.75f));
assertEquals(expected, builder.createMinShouldMatchQuery("field", "one two three four", 0.99f));
}
@@ -157,9 +162,11 @@ public class TestQueryBuilder extends Lu
/** simple synonyms test */
public void testSynonyms() throws Exception {
- BooleanQuery expected = new BooleanQuery(true);
- expected.add(new TermQuery(new Term("field", "dogs")), BooleanClause.Occur.SHOULD);
- expected.add(new TermQuery(new Term("field", "dog")), BooleanClause.Occur.SHOULD);
+ BooleanQuery.Builder expectedB = new BooleanQuery.Builder();
+ expectedB.setDisableCoord(true);
+ expectedB.add(new TermQuery(new Term("field", "dogs")), BooleanClause.Occur.SHOULD);
+ expectedB.add(new TermQuery(new Term("field", "dog")), BooleanClause.Occur.SHOULD);
+ Query expected = expectedB.build();
QueryBuilder builder = new QueryBuilder(new MockSynonymAnalyzer());
assertEquals(expected, builder.createBooleanQuery("field", "dogs"));
assertEquals(expected, builder.createPhraseQuery("field", "dogs"));
@@ -205,12 +212,12 @@ public class TestQueryBuilder extends Lu
// individual CJK chars as terms
SimpleCJKAnalyzer analyzer = new SimpleCJKAnalyzer();
- BooleanQuery expected = new BooleanQuery();
+ BooleanQuery.Builder expected = new BooleanQuery.Builder();
expected.add(new TermQuery(new Term("field", "ä¸")), BooleanClause.Occur.SHOULD);
expected.add(new TermQuery(new Term("field", "å½")), BooleanClause.Occur.SHOULD);
QueryBuilder builder = new QueryBuilder(analyzer);
- assertEquals(expected, builder.createBooleanQuery("field", "ä¸å½"));
+ assertEquals(expected.build(), builder.createBooleanQuery("field", "ä¸å½"));
}
public void testCJKPhrase() throws Exception {
@@ -274,69 +281,76 @@ public class TestQueryBuilder extends Lu
/** simple CJK synonym test */
public void testCJKSynonym() throws Exception {
- BooleanQuery expected = new BooleanQuery(true);
+ BooleanQuery.Builder expected = new BooleanQuery.Builder();
+ expected.setDisableCoord(true);
expected.add(new TermQuery(new Term("field", "å½")), BooleanClause.Occur.SHOULD);
expected.add(new TermQuery(new Term("field", "å")), BooleanClause.Occur.SHOULD);
QueryBuilder builder = new QueryBuilder(new MockCJKSynonymAnalyzer());
- assertEquals(expected, builder.createBooleanQuery("field", "å½"));
- assertEquals(expected, builder.createPhraseQuery("field", "å½"));
- assertEquals(expected, builder.createBooleanQuery("field", "å½", BooleanClause.Occur.MUST));
+ assertEquals(expected.build(), builder.createBooleanQuery("field", "å½"));
+ assertEquals(expected.build(), builder.createPhraseQuery("field", "å½"));
+ assertEquals(expected.build(), builder.createBooleanQuery("field", "å½", BooleanClause.Occur.MUST));
}
/** synonyms with default OR operator */
public void testCJKSynonymsOR() throws Exception {
- BooleanQuery expected = new BooleanQuery();
+ BooleanQuery.Builder expected = new BooleanQuery.Builder();
expected.add(new TermQuery(new Term("field", "ä¸")), BooleanClause.Occur.SHOULD);
- BooleanQuery inner = new BooleanQuery(true);
+ BooleanQuery.Builder inner = new BooleanQuery.Builder();
+ inner.setDisableCoord(true);
inner.add(new TermQuery(new Term("field", "å½")), BooleanClause.Occur.SHOULD);
inner.add(new TermQuery(new Term("field", "å")), BooleanClause.Occur.SHOULD);
- expected.add(inner, BooleanClause.Occur.SHOULD);
+ expected.add(inner.build(), BooleanClause.Occur.SHOULD);
QueryBuilder builder = new QueryBuilder(new MockCJKSynonymAnalyzer());
- assertEquals(expected, builder.createBooleanQuery("field", "ä¸å½"));
+ assertEquals(expected.build(), builder.createBooleanQuery("field", "ä¸å½"));
}
/** more complex synonyms with default OR operator */
public void testCJKSynonymsOR2() throws Exception {
- BooleanQuery expected = new BooleanQuery();
+ BooleanQuery.Builder expected = new BooleanQuery.Builder();
expected.add(new TermQuery(new Term("field", "ä¸")), BooleanClause.Occur.SHOULD);
- BooleanQuery inner = new BooleanQuery(true);
+ BooleanQuery.Builder inner = new BooleanQuery.Builder();
+ inner.setDisableCoord(true);
inner.add(new TermQuery(new Term("field", "å½")), BooleanClause.Occur.SHOULD);
inner.add(new TermQuery(new Term("field", "å")), BooleanClause.Occur.SHOULD);
- expected.add(inner, BooleanClause.Occur.SHOULD);
- BooleanQuery inner2 = new BooleanQuery(true);
+ expected.add(inner.build(), BooleanClause.Occur.SHOULD);
+ BooleanQuery.Builder inner2 = new BooleanQuery.Builder();
+ inner2.setDisableCoord(true);
inner2.add(new TermQuery(new Term("field", "å½")), BooleanClause.Occur.SHOULD);
inner2.add(new TermQuery(new Term("field", "å")), BooleanClause.Occur.SHOULD);
- expected.add(inner2, BooleanClause.Occur.SHOULD);
+ expected.add(inner2.build(), BooleanClause.Occur.SHOULD);
QueryBuilder builder = new QueryBuilder(new MockCJKSynonymAnalyzer());
- assertEquals(expected, builder.createBooleanQuery("field", "ä¸å½å½"));
+ assertEquals(expected.build(), builder.createBooleanQuery("field", "ä¸å½å½"));
}
/** synonyms with default AND operator */
public void testCJKSynonymsAND() throws Exception {
- BooleanQuery expected = new BooleanQuery();
+ BooleanQuery.Builder expected = new BooleanQuery.Builder();
expected.add(new TermQuery(new Term("field", "ä¸")), BooleanClause.Occur.MUST);
- BooleanQuery inner = new BooleanQuery(true);
+ BooleanQuery.Builder inner = new BooleanQuery.Builder();
+ inner.setDisableCoord(true);
inner.add(new TermQuery(new Term("field", "å½")), BooleanClause.Occur.SHOULD);
inner.add(new TermQuery(new Term("field", "å")), BooleanClause.Occur.SHOULD);
- expected.add(inner, BooleanClause.Occur.MUST);
+ expected.add(inner.build(), BooleanClause.Occur.MUST);
QueryBuilder builder = new QueryBuilder(new MockCJKSynonymAnalyzer());
- assertEquals(expected, builder.createBooleanQuery("field", "ä¸å½", BooleanClause.Occur.MUST));
+ assertEquals(expected.build(), builder.createBooleanQuery("field", "ä¸å½", BooleanClause.Occur.MUST));
}
/** more complex synonyms with default AND operator */
public void testCJKSynonymsAND2() throws Exception {
- BooleanQuery expected = new BooleanQuery();
+ BooleanQuery.Builder expected = new BooleanQuery.Builder();
expected.add(new TermQuery(new Term("field", "ä¸")), BooleanClause.Occur.MUST);
- BooleanQuery inner = new BooleanQuery(true);
+ BooleanQuery.Builder inner = new BooleanQuery.Builder();
+ inner.setDisableCoord(true);
inner.add(new TermQuery(new Term("field", "å½")), BooleanClause.Occur.SHOULD);
inner.add(new TermQuery(new Term("field", "å")), BooleanClause.Occur.SHOULD);
- expected.add(inner, BooleanClause.Occur.MUST);
- BooleanQuery inner2 = new BooleanQuery(true);
+ expected.add(inner.build(), BooleanClause.Occur.MUST);
+ BooleanQuery.Builder inner2 = new BooleanQuery.Builder();
+ inner2.setDisableCoord(true);
inner2.add(new TermQuery(new Term("field", "å½")), BooleanClause.Occur.SHOULD);
inner2.add(new TermQuery(new Term("field", "å")), BooleanClause.Occur.SHOULD);
- expected.add(inner2, BooleanClause.Occur.MUST);
+ expected.add(inner2.build(), BooleanClause.Occur.MUST);
QueryBuilder builder = new QueryBuilder(new MockCJKSynonymAnalyzer());
- assertEquals(expected, builder.createBooleanQuery("field", "ä¸å½å½", BooleanClause.Occur.MUST));
+ assertEquals(expected.build(), builder.createBooleanQuery("field", "ä¸å½å½", BooleanClause.Occur.MUST));
}
/** forms multiphrase query */
Modified: lucene/dev/trunk/lucene/demo/src/java/org/apache/lucene/demo/facet/DistanceFacetsExample.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/demo/src/java/org/apache/lucene/demo/facet/DistanceFacetsExample.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/demo/src/java/org/apache/lucene/demo/facet/DistanceFacetsExample.java (original)
+++ lucene/dev/trunk/lucene/demo/src/java/org/apache/lucene/demo/facet/DistanceFacetsExample.java Thu Jun 18 07:14:05 2015
@@ -180,7 +180,7 @@ public class DistanceFacetsExample imple
maxLng = Math.toRadians(180);
}
- BooleanQuery f = new BooleanQuery();
+ BooleanQuery.Builder f = new BooleanQuery.Builder();
// Add latitude range filter:
f.add(NumericRangeQuery.newDoubleRange("latitude", Math.toDegrees(minLat), Math.toDegrees(maxLat), true, true),
@@ -190,18 +190,18 @@ public class DistanceFacetsExample imple
if (minLng > maxLng) {
// The bounding box crosses the international date
// line:
- BooleanQuery lonF = new BooleanQuery();
+ BooleanQuery.Builder lonF = new BooleanQuery.Builder();
lonF.add(NumericRangeQuery.newDoubleRange("longitude", Math.toDegrees(minLng), null, true, true),
BooleanClause.Occur.SHOULD);
lonF.add(NumericRangeQuery.newDoubleRange("longitude", null, Math.toDegrees(maxLng), true, true),
BooleanClause.Occur.SHOULD);
- f.add(lonF, BooleanClause.Occur.MUST);
+ f.add(lonF.build(), BooleanClause.Occur.MUST);
} else {
f.add(NumericRangeQuery.newDoubleRange("longitude", Math.toDegrees(minLng), Math.toDegrees(maxLng), true, true),
BooleanClause.Occur.FILTER);
}
- return new QueryWrapperFilter(f);
+ return new QueryWrapperFilter(f.build());
}
/** User runs a query and counts facets. */
Modified: lucene/dev/trunk/lucene/expressions/src/test/org/apache/lucene/expressions/TestExpressionSorts.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/expressions/src/test/org/apache/lucene/expressions/TestExpressionSorts.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/expressions/src/test/org/apache/lucene/expressions/TestExpressionSorts.java (original)
+++ lucene/dev/trunk/lucene/expressions/src/test/org/apache/lucene/expressions/TestExpressionSorts.java Thu Jun 18 07:14:05 2015
@@ -88,14 +88,14 @@ public class TestExpressionSorts extends
for (int i = 0; i < n; i++) {
assertQuery(new MatchAllDocsQuery());
assertQuery(new TermQuery(new Term("english", "one")));
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(new TermQuery(new Term("english", "one")), BooleanClause.Occur.SHOULD);
bq.add(new TermQuery(new Term("oddeven", "even")), BooleanClause.Occur.SHOULD);
- assertQuery(bq);
+ assertQuery(bq.build());
// force in order
bq.add(new TermQuery(new Term("english", "two")), BooleanClause.Occur.SHOULD);
bq.setMinimumNumberShouldMatch(2);
- assertQuery(bq);
+ assertQuery(bq.build());
}
}
Modified: lucene/dev/trunk/lucene/facet/src/java/org/apache/lucene/facet/DrillDownQuery.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/facet/src/java/org/apache/lucene/facet/DrillDownQuery.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/facet/src/java/org/apache/lucene/facet/DrillDownQuery.java (original)
+++ lucene/dev/trunk/lucene/facet/src/java/org/apache/lucene/facet/DrillDownQuery.java Thu Jun 18 07:14:05 2015
@@ -22,11 +22,11 @@ import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
+import java.util.Objects;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.BooleanClause.Occur;
-import org.apache.lucene.search.BooleanClause;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.ConstantScoreQuery;
import org.apache.lucene.search.Filter;
@@ -55,43 +55,23 @@ public final class DrillDownQuery extend
}
private final FacetsConfig config;
- private final BooleanQuery query;
+ private final Query baseQuery;
+ private final List<BooleanQuery.Builder> dimQueries = new ArrayList<>();
private final Map<String,Integer> drillDownDims = new LinkedHashMap<>();
- /** Used by clone() */
- DrillDownQuery(FacetsConfig config, BooleanQuery query, Map<String,Integer> drillDownDims) {
- this.query = query.clone();
+ /** Used by clone() and DrillSideways */
+ DrillDownQuery(FacetsConfig config, Query baseQuery, List<BooleanQuery.Builder> dimQueries, Map<String,Integer> drillDownDims) {
+ this.baseQuery = baseQuery;
+ this.dimQueries.addAll(dimQueries);
this.drillDownDims.putAll(drillDownDims);
this.config = config;
}
/** Used by DrillSideways */
DrillDownQuery(FacetsConfig config, Filter filter, DrillDownQuery other) {
- query = new BooleanQuery(true); // disable coord
-
- BooleanClause[] clauses = other.query.getClauses();
- if (clauses.length == other.drillDownDims.size()) {
- throw new IllegalArgumentException("cannot apply filter unless baseQuery isn't null; pass ConstantScoreQuery instead");
- }
- assert clauses.length == 1+other.drillDownDims.size(): clauses.length + " vs " + (1+other.drillDownDims.size());
- drillDownDims.putAll(other.drillDownDims);
- query.add(new FilteredQuery(clauses[0].getQuery(), filter), Occur.MUST);
- for(int i=1;i<clauses.length;i++) {
- query.add(clauses[i].getQuery(), Occur.MUST);
- }
- this.config = config;
- }
-
- /** Used by DrillSideways */
- DrillDownQuery(FacetsConfig config, Query baseQuery, List<Query> clauses, Map<String,Integer> drillDownDims) {
- query = new BooleanQuery(true);
- if (baseQuery != null) {
- query.add(baseQuery, Occur.MUST);
- }
- for(Query clause : clauses) {
- query.add(clause, Occur.MUST);
- }
- this.drillDownDims.putAll(drillDownDims);
+ this.baseQuery = new FilteredQuery(other.baseQuery == null ? new MatchAllDocsQuery() : other.baseQuery, filter);
+ this.dimQueries.addAll(other.dimQueries);
+ this.drillDownDims.putAll(other.drillDownDims);
this.config = config;
}
@@ -107,88 +87,32 @@ public final class DrillDownQuery extend
* {@link #rewrite(IndexReader)} will be a pure browsing query, filtering on
* the added categories only. */
public DrillDownQuery(FacetsConfig config, Query baseQuery) {
- query = new BooleanQuery(true); // disable coord
- if (baseQuery != null) {
- query.add(baseQuery, Occur.MUST);
- }
+ this.baseQuery = baseQuery;
this.config = config;
}
- /** Merges (ORs) a new path into an existing AND'd
- * clause. */
- private void merge(String dim, String[] path) {
- int index = drillDownDims.get(dim);
- if (query.getClauses().length == drillDownDims.size()+1) {
- index++;
- }
- ConstantScoreQuery q = (ConstantScoreQuery) query.clauses().get(index).getQuery();
- if ((q.getQuery() instanceof BooleanQuery) == false) {
- // App called .add(dim, customQuery) and then tried to
- // merge a facet label in:
- throw new RuntimeException("cannot merge with custom Query");
- }
- String indexedField = config.getDimConfig(dim).indexFieldName;
-
- BooleanQuery bq = (BooleanQuery) q.getQuery();
- bq.add(new TermQuery(term(indexedField, dim, path)), Occur.SHOULD);
- }
-
/** Adds one dimension of drill downs; if you pass the same
* dimension more than once it is OR'd with the previous
* cofnstraints on that dimension, and all dimensions are
* AND'd against each other and the base query. */
public void add(String dim, String... path) {
-
- if (drillDownDims.containsKey(dim)) {
- merge(dim, path);
- return;
- }
String indexedField = config.getDimConfig(dim).indexFieldName;
-
- BooleanQuery bq = new BooleanQuery(true); // disable coord
- bq.add(new TermQuery(term(indexedField, dim, path)), Occur.SHOULD);
-
- add(dim, bq);
+ add(dim, new TermQuery(term(indexedField, dim, path)));
}
/** Expert: add a custom drill-down subQuery. Use this
* when you have a separate way to drill-down on the
* dimension than the indexed facet ordinals. */
public void add(String dim, Query subQuery) {
-
- if (drillDownDims.containsKey(dim)) {
- throw new IllegalArgumentException("dimension \"" + dim + "\" already has a drill-down");
- }
- // TODO: we should use FilteredQuery?
-
- // So scores of the drill-down query don't have an
- // effect:
- final ConstantScoreQuery drillDownQuery = new ConstantScoreQuery(subQuery);
- drillDownQuery.setBoost(0.0f);
-
- query.add(drillDownQuery, Occur.MUST);
-
- drillDownDims.put(dim, drillDownDims.size());
- }
-
- /** Expert: add a custom drill-down Filter, e.g. when
- * drilling down after range faceting. */
- public void add(String dim, Filter subFilter) {
-
- if (drillDownDims.containsKey(dim)) {
- throw new IllegalArgumentException("dimension \"" + dim + "\" already has a drill-down");
+ assert drillDownDims.size() == dimQueries.size();
+ if (drillDownDims.containsKey(dim) == false) {
+ drillDownDims.put(dim, drillDownDims.size());
+ BooleanQuery.Builder builder = new BooleanQuery.Builder();
+ builder.setDisableCoord(true);
+ dimQueries.add(builder);
}
-
- // TODO: we should use FilteredQuery?
-
- // So scores of the drill-down query don't have an
- // effect:
- final ConstantScoreQuery drillDownQuery = new ConstantScoreQuery(subFilter);
- drillDownQuery.setBoost(0.0f);
-
- query.add(drillDownQuery, Occur.MUST);
-
- drillDownDims.put(dim, drillDownDims.size());
+ final int index = drillDownDims.get(dim);
+ dimQueries.get(index).add(subQuery, Occur.SHOULD);
}
static Filter getFilter(Query query) {
@@ -207,97 +131,59 @@ public final class DrillDownQuery extend
@Override
public DrillDownQuery clone() {
- return new DrillDownQuery(config, query, drillDownDims);
+ return new DrillDownQuery(config, baseQuery, dimQueries, drillDownDims);
}
@Override
public int hashCode() {
- final int prime = 31;
- int result = super.hashCode();
- return prime * result + query.hashCode();
+ return 31 * super.hashCode() + Objects.hash(baseQuery, dimQueries);
}
@Override
public boolean equals(Object obj) {
- if (!(obj instanceof DrillDownQuery)) {
+ if (super.equals(obj) == false) {
return false;
}
-
DrillDownQuery other = (DrillDownQuery) obj;
- return query.equals(other.query) && super.equals(other);
+ return Objects.equals(baseQuery, other.baseQuery)
+ && dimQueries.equals(other.dimQueries);
}
@Override
public Query rewrite(IndexReader r) throws IOException {
- if (query.clauses().size() == 0) {
+ BooleanQuery rewritten = getBooleanQuery();
+ if (rewritten.clauses().isEmpty()) {
return new MatchAllDocsQuery();
}
+ return rewritten;
+ }
- List<Filter> filters = new ArrayList<>();
- List<Query> queries = new ArrayList<>();
- List<BooleanClause> clauses = query.clauses();
- Query baseQuery;
- int startIndex;
- if (drillDownDims.size() == query.clauses().size()) {
- baseQuery = new MatchAllDocsQuery();
- startIndex = 0;
- } else {
- baseQuery = clauses.get(0).getQuery();
- startIndex = 1;
- }
+ @Override
+ public String toString(String field) {
+ return getBooleanQuery().toString(field);
+ }
- for(int i=startIndex;i<clauses.size();i++) {
- BooleanClause clause = clauses.get(i);
- Query queryClause = clause.getQuery();
- Filter filter = getFilter(queryClause);
- if (filter != null) {
- filters.add(filter);
- } else {
- queries.add(queryClause);
- }
+ private BooleanQuery getBooleanQuery() {
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
+ if (baseQuery != null) {
+ bq.add(baseQuery, Occur.MUST);
}
-
- if (filters.isEmpty()) {
- return query;
- } else {
- // Wrap all filters using FilteredQuery
-
- // TODO: this is hackish; we need to do it because
- // BooleanQuery can't be trusted to handle the
- // "expensive filter" case. Really, each Filter should
- // know its cost and we should take that more
- // carefully into account when picking the right
- // strategy/optimization:
- Query wrapped;
- if (queries.isEmpty()) {
- wrapped = baseQuery;
- } else {
- // disable coord
- BooleanQuery wrappedBQ = new BooleanQuery(true);
- if ((baseQuery instanceof MatchAllDocsQuery) == false) {
- wrappedBQ.add(baseQuery, BooleanClause.Occur.MUST);
- }
- for(Query q : queries) {
- wrappedBQ.add(q, BooleanClause.Occur.MUST);
- }
- wrapped = wrappedBQ;
- }
-
- for(Filter filter : filters) {
- wrapped = new FilteredQuery(wrapped, filter, FilteredQuery.QUERY_FIRST_FILTER_STRATEGY);
- }
-
- return wrapped;
+ for (BooleanQuery.Builder builder : dimQueries) {
+ bq.add(builder.build(), Occur.FILTER);
}
+ return bq.build();
}
- @Override
- public String toString(String field) {
- return query.toString(field);
+ Query getBaseQuery() {
+ return baseQuery;
}
- BooleanQuery getBooleanQuery() {
- return query;
+ Query[] getDrillDownQueries() {
+ Query[] dimQueries = new Query[this.dimQueries.size()];
+ for (int i = 0; i < dimQueries.length; ++i) {
+ dimQueries[i] = this.dimQueries.get(i).build();
+ }
+ return dimQueries;
}
Map<String,Integer> getDims() {
Modified: lucene/dev/trunk/lucene/facet/src/java/org/apache/lucene/facet/DrillSideways.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/facet/src/java/org/apache/lucene/facet/DrillSideways.java?rev=1686145&r1=1686144&r2=1686145&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/facet/src/java/org/apache/lucene/facet/DrillSideways.java (original)
+++ lucene/dev/trunk/lucene/facet/src/java/org/apache/lucene/facet/DrillSideways.java Thu Jun 18 07:14:05 2015
@@ -27,9 +27,6 @@ import org.apache.lucene.facet.sortedset
import org.apache.lucene.facet.taxonomy.FastTaxonomyFacetCounts;
import org.apache.lucene.facet.taxonomy.TaxonomyReader;
import org.apache.lucene.search.FilterCollector;
-import org.apache.lucene.search.LeafCollector;
-import org.apache.lucene.search.BooleanClause;
-import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.Collector;
import org.apache.lucene.search.FieldDoc;
import org.apache.lucene.search.Filter;
@@ -134,7 +131,6 @@ public class DrillSideways {
* Search, collecting hits with a {@link Collector}, and
* computing drill down and sideways counts.
*/
- @SuppressWarnings({"rawtypes","unchecked"})
public DrillSidewaysResult search(DrillDownQuery query, Collector hitCollector) throws IOException {
Map<String,Integer> drillDownDims = query.getDims();
@@ -148,31 +144,19 @@ public class DrillSideways {
return new DrillSidewaysResult(buildFacetsResult(drillDownCollector, null, null), null);
}
- BooleanQuery ddq = query.getBooleanQuery();
- BooleanClause[] clauses = ddq.getClauses();
-
- Query baseQuery;
- int startClause;
- if (clauses.length == drillDownDims.size()) {
+ Query baseQuery = query.getBaseQuery();
+ if (baseQuery == null) {
// TODO: we could optimize this pure-browse case by
// making a custom scorer instead:
baseQuery = new MatchAllDocsQuery();
- startClause = 0;
- } else {
- assert clauses.length == 1+drillDownDims.size();
- baseQuery = clauses[0].getQuery();
- startClause = 1;
}
+ Query[] drillDownQueries = query.getDrillDownQueries();
FacetsCollector[] drillSidewaysCollectors = new FacetsCollector[drillDownDims.size()];
for (int i = 0; i < drillSidewaysCollectors.length; i++) {
drillSidewaysCollectors[i] = new FacetsCollector();
}
-
- Query[] drillDownQueries = new Query[clauses.length-startClause];
- for(int i=startClause;i<clauses.length;i++) {
- drillDownQueries[i-startClause] = clauses[i].getQuery();
- }
+
DrillSidewaysQuery dsq = new DrillSidewaysQuery(baseQuery, drillDownCollector, drillSidewaysCollectors, drillDownQueries, scoreSubDocsAtOnce());
if (hitCollector.needsScores() == false) {
// this is a borrible hack in order to make sure IndexSearcher will not