lucene-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jpou...@apache.org
Subject [1/2] lucene-solr:master: LUCENE-7330: Speed up conjunctions.
Date Mon, 13 Jun 2016 15:30:34 GMT
Repository: lucene-solr
Updated Branches:
  refs/heads/branch_6x 6d1bb1407 -> 4a02813e2
  refs/heads/master af2ae05d6 -> 72914198e


LUCENE-7330: Speed up conjunctions.


Project: http://git-wip-us.apache.org/repos/asf/lucene-solr/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucene-solr/commit/72914198
Tree: http://git-wip-us.apache.org/repos/asf/lucene-solr/tree/72914198
Diff: http://git-wip-us.apache.org/repos/asf/lucene-solr/diff/72914198

Branch: refs/heads/master
Commit: 72914198e60dcaa2008f6945e53e36e1c0053078
Parents: af2ae05
Author: Adrien Grand <jpountz@gmail.com>
Authored: Mon Jun 13 17:27:44 2016 +0200
Committer: Adrien Grand <jpountz@gmail.com>
Committed: Mon Jun 13 17:27:44 2016 +0200

----------------------------------------------------------------------
 lucene/CHANGES.txt                              |   4 +
 .../apache/lucene/search/ConjunctionDISI.java   | 188 ++++++++-----------
 .../apache/lucene/search/ConjunctionScorer.java |   4 +-
 .../apache/lucene/search/ExactPhraseScorer.java |   3 +-
 .../lucene/search/SloppyPhraseScorer.java       |   3 +-
 .../apache/lucene/search/TwoPhaseIterator.java  |  79 +++++---
 .../lucene/search/TestConjunctionDISI.java      |  12 +-
 7 files changed, 145 insertions(+), 148 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/72914198/lucene/CHANGES.txt
----------------------------------------------------------------------
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt
index 5a83c31..3c52440 100644
--- a/lucene/CHANGES.txt
+++ b/lucene/CHANGES.txt
@@ -40,6 +40,10 @@ Improvements
   IndexReader after (illegally) removing the old index and
   reindexing (Vitaly Funstein, Robert Muir, Mike McCandless)
 
+Optimizations
+
+* LUCENE-7330: Speed up conjunction queries. (Adrien Grand)
+
 Other
 
 * LUCENE-4787: Fixed some highlighting javadocs. (Michael Dodsworth via Adrien

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/72914198/lucene/core/src/java/org/apache/lucene/search/ConjunctionDISI.java
----------------------------------------------------------------------
diff --git a/lucene/core/src/java/org/apache/lucene/search/ConjunctionDISI.java b/lucene/core/src/java/org/apache/lucene/search/ConjunctionDISI.java
index 53e3753..205a349 100644
--- a/lucene/core/src/java/org/apache/lucene/search/ConjunctionDISI.java
+++ b/lucene/core/src/java/org/apache/lucene/search/ConjunctionDISI.java
@@ -31,11 +31,13 @@ import org.apache.lucene.util.CollectionUtil;
  * <br>Public only for use in {@link org.apache.lucene.search.spans}.
  * @lucene.internal
  */
-public class ConjunctionDISI extends DocIdSetIterator {
+public final class ConjunctionDISI extends DocIdSetIterator {
 
-  /** Create a conjunction over the provided {@link Scorer}s, taking advantage
-   *  of {@link TwoPhaseIterator}. */
-  public static ConjunctionDISI intersectScorers(List<Scorer> scorers) {
+  /** Create a conjunction over the provided {@link Scorer}s. Note that the
+   * returned {@link DocIdSetIterator} might leverage two-phase iteration in
+   * which case it is possible to retrieve the {@link TwoPhaseIterator} using
+   * {@link TwoPhaseIterator#unwrap}. */
+  public static DocIdSetIterator intersectScorers(List<Scorer> scorers) {
     if (scorers.size() < 2) {
       throw new IllegalArgumentException("Cannot make a ConjunctionDISI of less than 2 iterators");
     }
@@ -45,15 +47,18 @@ public class ConjunctionDISI extends DocIdSetIterator {
       addScorer(scorer, allIterators, twoPhaseIterators);
     }
 
-    if (twoPhaseIterators.isEmpty()) {
-      return new ConjunctionDISI(allIterators);
-    } else {
-      return new TwoPhase(allIterators, twoPhaseIterators);
+    DocIdSetIterator iterator = new ConjunctionDISI(allIterators);
+    if (twoPhaseIterators.isEmpty() == false) {
+      iterator = TwoPhaseIterator.asDocIdSetIterator(new ConjunctionTwoPhaseIterator(iterator,
twoPhaseIterators));
     }
+    return iterator;
   }
 
-  /** Create a conjunction over the provided DocIdSetIterators. */
-  public static ConjunctionDISI intersectIterators(List<DocIdSetIterator> iterators)
{
+  /** Create a conjunction over the provided DocIdSetIterators. Note that the
+   * returned {@link DocIdSetIterator} might leverage two-phase iteration in
+   * which case it is possible to retrieve the {@link TwoPhaseIterator} using
+   * {@link TwoPhaseIterator#unwrap}. */
+  public static DocIdSetIterator intersectIterators(List<DocIdSetIterator> iterators)
{
     if (iterators.size() < 2) {
       throw new IllegalArgumentException("Cannot make a ConjunctionDISI of less than 2 iterators");
     }
@@ -63,16 +68,18 @@ public class ConjunctionDISI extends DocIdSetIterator {
       addIterator(iterator, allIterators, twoPhaseIterators);
     }
 
-    if (twoPhaseIterators.isEmpty()) {
-      return new ConjunctionDISI(allIterators);
-    } else {
-      return new TwoPhase(allIterators, twoPhaseIterators);
+    DocIdSetIterator iterator = new ConjunctionDISI(allIterators);
+    if (twoPhaseIterators.isEmpty() == false) {
+      iterator = TwoPhaseIterator.asDocIdSetIterator(new ConjunctionTwoPhaseIterator(iterator,
twoPhaseIterators));
     }
+    return iterator;
   }
 
-  /** Create a conjunction over the provided {@link Scorer}s, taking advantage
-   *  of {@link TwoPhaseIterator}. */
-  public static ConjunctionDISI intersectSpans(List<Spans> spanList) {
+  /** Create a conjunction over the provided {@link Spans}. Note that the
+   * returned {@link DocIdSetIterator} might leverage two-phase iteration in
+   * which case it is possible to retrieve the {@link TwoPhaseIterator} using
+   * {@link TwoPhaseIterator#unwrap}. */
+  public static DocIdSetIterator intersectSpans(List<Spans> spanList) {
     if (spanList.size() < 2) {
       throw new IllegalArgumentException("Cannot make a ConjunctionDISI of less than 2 iterators");
     }
@@ -82,11 +89,11 @@ public class ConjunctionDISI extends DocIdSetIterator {
       addSpans(spans, allIterators, twoPhaseIterators);
     }
 
-    if (twoPhaseIterators.isEmpty()) {
-      return new ConjunctionDISI(allIterators);
-    } else {
-      return new TwoPhase(allIterators, twoPhaseIterators);
+    DocIdSetIterator iterator = new ConjunctionDISI(allIterators);
+    if (twoPhaseIterators.isEmpty() == false) {
+      iterator = TwoPhaseIterator.asDocIdSetIterator(new ConjunctionTwoPhaseIterator(iterator,
twoPhaseIterators));
     }
+    return iterator;
   }
 
   /** Adds the scorer, possibly splitting up into two phases or collapsing if it is another
conjunction */
@@ -110,17 +117,16 @@ public class ConjunctionDISI extends DocIdSetIterator {
   }
 
   private static void addIterator(DocIdSetIterator disi, List<DocIdSetIterator> allIterators,
List<TwoPhaseIterator> twoPhaseIterators) {
-    // Check for exactly this class for collapsing. Subclasses can do their own optimizations.
-    if (disi.getClass() == ConjunctionDISI.class || disi.getClass() == TwoPhase.class) {
+    TwoPhaseIterator twoPhase = TwoPhaseIterator.unwrap(disi);
+    if (twoPhase != null) {
+      addTwoPhaseIterator(twoPhase, allIterators, twoPhaseIterators);
+    } else if (disi.getClass() == ConjunctionDISI.class) { // Check for exactly this class
for collapsing
       ConjunctionDISI conjunction = (ConjunctionDISI) disi;
       // subconjuctions have already split themselves into two phase iterators and others,
so we can take those
       // iterators as they are and move them up to this conjunction
-      allIterators.add(conjunction.lead);
+      allIterators.add(conjunction.lead1);
+      allIterators.add(conjunction.lead2);
       Collections.addAll(allIterators, conjunction.others);
-      if (conjunction.getClass() == TwoPhase.class) {
-        TwoPhase twoPhase = (TwoPhase) conjunction;
-        Collections.addAll(twoPhaseIterators, twoPhase.twoPhaseView.twoPhaseIterators);
-      }
     } else {
       allIterators.add(disi);
     }
@@ -128,13 +134,17 @@ public class ConjunctionDISI extends DocIdSetIterator {
 
   private static void addTwoPhaseIterator(TwoPhaseIterator twoPhaseIter, List<DocIdSetIterator>
allIterators, List<TwoPhaseIterator> twoPhaseIterators) {
     addIterator(twoPhaseIter.approximation(), allIterators, twoPhaseIterators);
-    twoPhaseIterators.add(twoPhaseIter);
+    if (twoPhaseIter.getClass() == ConjunctionTwoPhaseIterator.class) { // Check for exactly
this class for collapsing
+      Collections.addAll(twoPhaseIterators, ((ConjunctionTwoPhaseIterator) twoPhaseIter).twoPhaseIterators);
+    } else {
+      twoPhaseIterators.add(twoPhaseIter);
+    }
   }
 
-  final DocIdSetIterator lead;
+  final DocIdSetIterator lead1, lead2;
   final DocIdSetIterator[] others;
 
-  ConjunctionDISI(List<? extends DocIdSetIterator> iterators) {
+  private ConjunctionDISI(List<? extends DocIdSetIterator> iterators) {
     assert iterators.size() >= 2;
     // Sort the array the first time to allow the least frequent DocsEnum to
     // lead the matching.
@@ -144,84 +154,77 @@ public class ConjunctionDISI extends DocIdSetIterator {
         return Long.compare(o1.cost(), o2.cost());
       }
     });
-    lead = iterators.get(0);
-    others = iterators.subList(1, iterators.size()).toArray(new DocIdSetIterator[0]);
-  }
-
-  protected boolean matches() throws IOException {
-    return true;
-  }
-
-  TwoPhaseIterator asTwoPhaseIterator() {
-    return null;
+    lead1 = iterators.get(0);
+    lead2 = iterators.get(1);
+    others = iterators.subList(2, iterators.size()).toArray(new DocIdSetIterator[0]);
   }
 
   private int doNext(int doc) throws IOException {
-    for(;;) {
-
-      if (doc == NO_MORE_DOCS) {
-        // we need this check because it is only ok to call #matches when positioned
-        return NO_MORE_DOCS;
+    advanceHead: for(;;) {
+      assert doc == lead1.docID();
+
+      // find agreement between the two iterators with the lower costs
+      // we special case them because they do not need the
+      // 'other.docID() < doc' check that the 'others' iterators need
+      final int next2 = lead2.advance(doc);
+      if (next2 != doc) {
+        doc = lead1.advance(next2);
+        if (next2 != doc) {
+          continue;
+        }
       }
 
-      advanceHead: for(;;) {
-        for (DocIdSetIterator other : others) {
-          // invariant: docsAndFreqs[i].doc <= doc at this point.
-
-          // docsAndFreqs[i].doc may already be equal to doc if we "broke advanceHead"
-          // on the previous iteration and the advance on the lead scorer exactly matched.
-          if (other.docID() < doc) {
-            final int next = other.advance(doc);
-
-            if (next > doc) {
-              // DocsEnum beyond the current doc - break and advance lead to the new highest
doc.
-              doc = lead.advance(next);
-              break advanceHead;
-            }
+      // then find agreement with other iterators
+      for (DocIdSetIterator other : others) {
+        // other.doc may already be equal to doc if we "continued advanceHead"
+        // on the previous iteration and the advance on the lead scorer exactly matched.
+        if (other.docID() < doc) {
+          final int next = other.advance(doc);
+
+          if (next > doc) {
+            // iterator beyond the current doc - advance lead and continue to the new highest
doc.
+            doc = lead1.advance(next);
+            continue advanceHead;
           }
         }
-
-        if (matches()) {
-          // success - all DocsEnums are on the same doc
-          return doc;
-        } else {
-          doc = lead.nextDoc();
-          break advanceHead;
-        }
       }
+
+      // success - all iterators are on the same doc
+      return doc;
     }
   }
 
   @Override
   public int advance(int target) throws IOException {
-    return doNext(lead.advance(target));
+    return doNext(lead1.advance(target));
   }
 
   @Override
   public int docID() {
-    return lead.docID();
+    return lead1.docID();
   }
 
   @Override
   public int nextDoc() throws IOException {
-    return doNext(lead.nextDoc());
+    return doNext(lead1.nextDoc());
   }
 
   @Override
   public long cost() {
-    return lead.cost(); // overestimate
+    return lead1.cost(); // overestimate
   }
 
   /**
-   * {@link TwoPhaseIterator} view of a {@link TwoPhase} conjunction.
+   * {@link TwoPhaseIterator} implementing a conjunction.
    */
-  private static class TwoPhaseConjunctionDISI extends TwoPhaseIterator {
+  private static final class ConjunctionTwoPhaseIterator extends TwoPhaseIterator {
 
     private final TwoPhaseIterator[] twoPhaseIterators;
     private final float matchCost;
 
-    private TwoPhaseConjunctionDISI(List<? extends DocIdSetIterator> iterators, List<TwoPhaseIterator>
twoPhaseIterators) {
-      super(new ConjunctionDISI(iterators));
+    private ConjunctionTwoPhaseIterator(DocIdSetIterator approximation,
+        List<? extends TwoPhaseIterator> twoPhaseIterators) {
+      super(approximation);
       assert twoPhaseIterators.size() > 0;
 
       CollectionUtil.timSort(twoPhaseIterators, new Comparator<TwoPhaseIterator>()
{
@@ -259,37 +262,4 @@ public class ConjunctionDISI extends DocIdSetIterator {
 
   }
 
-  /**
-   * A conjunction DISI built on top of approximations. This implementation
-   * verifies that documents actually match by consulting the provided
-   * {@link TwoPhaseIterator}s.
-   *
-   * Another important difference with {@link ConjunctionDISI} is that this
-   * implementation supports approximations too: the approximation of this
-   * impl is the conjunction of the approximations of the wrapped iterators.
-   * This allows eg. {@code +"A B" +C} to be approximated as
-   * {@code +(+A +B) +C}.
-   */
-  // NOTE: this is essentially the same as TwoPhaseDocIdSetIterator.asDocIdSetIterator
-  // but is its own impl in order to be able to expose a two-phase view
-  private static class TwoPhase extends ConjunctionDISI {
-
-    final TwoPhaseConjunctionDISI twoPhaseView;
-
-    private TwoPhase(List<? extends DocIdSetIterator> iterators, List<TwoPhaseIterator>
twoPhaseIterators) {
-      super(iterators);
-      twoPhaseView = new TwoPhaseConjunctionDISI(iterators, twoPhaseIterators);
-    }
-
-    @Override
-    public TwoPhaseConjunctionDISI asTwoPhaseIterator() {
-      return twoPhaseView;
-    }
-
-    @Override
-    protected boolean matches() throws IOException {
-      return twoPhaseView.matches();
-    }
-  }
-
 }

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/72914198/lucene/core/src/java/org/apache/lucene/search/ConjunctionScorer.java
----------------------------------------------------------------------
diff --git a/lucene/core/src/java/org/apache/lucene/search/ConjunctionScorer.java b/lucene/core/src/java/org/apache/lucene/search/ConjunctionScorer.java
index 066f07c..ab1de92 100644
--- a/lucene/core/src/java/org/apache/lucene/search/ConjunctionScorer.java
+++ b/lucene/core/src/java/org/apache/lucene/search/ConjunctionScorer.java
@@ -25,7 +25,7 @@ import java.util.List;
 /** Scorer for conjunctions, sets of queries, all of which are required. */
 class ConjunctionScorer extends Scorer {
 
-  final ConjunctionDISI disi;
+  final DocIdSetIterator disi;
   final Scorer[] scorers;
   final float coord;
 
@@ -44,7 +44,7 @@ class ConjunctionScorer extends Scorer {
 
   @Override
   public TwoPhaseIterator twoPhaseIterator() {
-    return disi.asTwoPhaseIterator();
+    return TwoPhaseIterator.unwrap(disi);
   }
 
   @Override

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/72914198/lucene/core/src/java/org/apache/lucene/search/ExactPhraseScorer.java
----------------------------------------------------------------------
diff --git a/lucene/core/src/java/org/apache/lucene/search/ExactPhraseScorer.java b/lucene/core/src/java/org/apache/lucene/search/ExactPhraseScorer.java
index c3c8b71..f5ccc7c 100644
--- a/lucene/core/src/java/org/apache/lucene/search/ExactPhraseScorer.java
+++ b/lucene/core/src/java/org/apache/lucene/search/ExactPhraseScorer.java
@@ -37,7 +37,7 @@ final class ExactPhraseScorer extends Scorer {
     }
   }
 
-  private final ConjunctionDISI conjunction;
+  private final DocIdSetIterator conjunction;
   private final PostingsAndPosition[] postings;
 
   private int freq;
@@ -60,6 +60,7 @@ final class ExactPhraseScorer extends Scorer {
       postingsAndPositions.add(new PostingsAndPosition(posting.postings, posting.position));
     }
     conjunction = ConjunctionDISI.intersectIterators(iterators);
+    assert TwoPhaseIterator.unwrap(conjunction) == null;
     this.postings = postingsAndPositions.toArray(new PostingsAndPosition[postingsAndPositions.size()]);
     this.matchCost = matchCost;
   }

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/72914198/lucene/core/src/java/org/apache/lucene/search/SloppyPhraseScorer.java
----------------------------------------------------------------------
diff --git a/lucene/core/src/java/org/apache/lucene/search/SloppyPhraseScorer.java b/lucene/core/src/java/org/apache/lucene/search/SloppyPhraseScorer.java
index 2ee3e70..acc8282 100644
--- a/lucene/core/src/java/org/apache/lucene/search/SloppyPhraseScorer.java
+++ b/lucene/core/src/java/org/apache/lucene/search/SloppyPhraseScorer.java
@@ -31,7 +31,7 @@ import org.apache.lucene.util.FixedBitSet;
 
 final class SloppyPhraseScorer extends Scorer {
 
-  private final ConjunctionDISI conjunction;
+  private final DocIdSetIterator conjunction;
   private final PhrasePositions[] phrasePositions;
 
   private float sloppyFreq; //phrase frequency in current doc as computed by phraseFreq().
@@ -70,6 +70,7 @@ final class SloppyPhraseScorer extends Scorer {
       phrasePositions[i] = new PhrasePositions(postings[i].postings, postings[i].position,
i, postings[i].terms);
     }
     conjunction = ConjunctionDISI.intersectIterators(Arrays.asList(iterators));
+    assert TwoPhaseIterator.unwrap(conjunction) == null;
     this.matchCost = matchCost;
   }
 

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/72914198/lucene/core/src/java/org/apache/lucene/search/TwoPhaseIterator.java
----------------------------------------------------------------------
diff --git a/lucene/core/src/java/org/apache/lucene/search/TwoPhaseIterator.java b/lucene/core/src/java/org/apache/lucene/search/TwoPhaseIterator.java
index 38176bf..ff472e7 100644
--- a/lucene/core/src/java/org/apache/lucene/search/TwoPhaseIterator.java
+++ b/lucene/core/src/java/org/apache/lucene/search/TwoPhaseIterator.java
@@ -41,40 +41,61 @@ public abstract class TwoPhaseIterator {
   /** Return a {@link DocIdSetIterator} view of the provided
    *  {@link TwoPhaseIterator}. */
   public static DocIdSetIterator asDocIdSetIterator(TwoPhaseIterator twoPhaseIterator) {
-    final DocIdSetIterator approximation = twoPhaseIterator.approximation();
-    return new DocIdSetIterator() {
-
-      @Override
-      public int docID() {
-        return approximation.docID();
-      }
-
-      @Override
-      public int nextDoc() throws IOException {
-        return doNext(approximation.nextDoc());
-      }
+    return new TwoPhaseIteratorAsDocIdSetIterator(twoPhaseIterator);
+  }
 
-      @Override
-      public int advance(int target) throws IOException {
-        return doNext(approximation.advance(target));
-      }
+  /**
+   * If the given {@link DocIdSetIterator} has been created with
+   * {@link #asDocIdSetIterator}, then this will return the wrapped
+   * {@link TwoPhaseIterator}. Otherwise this returns {@code null}.
+   */
+  public static TwoPhaseIterator unwrap(DocIdSetIterator iterator) {
+    if (iterator instanceof TwoPhaseIteratorAsDocIdSetIterator) {
+      return ((TwoPhaseIteratorAsDocIdSetIterator) iterator).twoPhaseIterator;
+    } else {
+      return null;
+    }
+  }
 
-      private int doNext(int doc) throws IOException {
-        for (;; doc = approximation.nextDoc()) {
-          if (doc == NO_MORE_DOCS) {
-            return NO_MORE_DOCS;
-          } else if (twoPhaseIterator.matches()) {
-            return doc;
-          }
+  private static class TwoPhaseIteratorAsDocIdSetIterator extends DocIdSetIterator {
+
+    final TwoPhaseIterator twoPhaseIterator;
+    final DocIdSetIterator approximation;
+
+    TwoPhaseIteratorAsDocIdSetIterator(TwoPhaseIterator twoPhaseIterator) {
+      this.twoPhaseIterator = twoPhaseIterator;
+      this.approximation = twoPhaseIterator.approximation;
+    }
+
+    @Override
+    public int docID() {
+      return approximation.docID();
+    }
+
+    @Override
+    public int nextDoc() throws IOException {
+      return doNext(approximation.nextDoc());
+    }
+
+    @Override
+    public int advance(int target) throws IOException {
+      return doNext(approximation.advance(target));
+    }
+
+    private int doNext(int doc) throws IOException {
+      for (;; doc = approximation.nextDoc()) {
+        if (doc == NO_MORE_DOCS) {
+          return NO_MORE_DOCS;
+        } else if (twoPhaseIterator.matches()) {
+          return doc;
         }
       }
+    }
 
-      @Override
-      public long cost() {
-        return approximation.cost();
-      }
-
-    };
+    @Override
+    public long cost() {
+      return approximation.cost();
+    }
   }
 
   /** Return an approximation. The returned {@link DocIdSetIterator} is a

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/72914198/lucene/core/src/test/org/apache/lucene/search/TestConjunctionDISI.java
----------------------------------------------------------------------
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestConjunctionDISI.java b/lucene/core/src/test/org/apache/lucene/search/TestConjunctionDISI.java
index 269990d..dcb6664 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestConjunctionDISI.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestConjunctionDISI.java
@@ -181,7 +181,7 @@ public class TestConjunctionDISI extends LuceneTestCase {
         }
       }
 
-      final ConjunctionDISI conjunction = ConjunctionDISI.intersectScorers(Arrays.asList(iterators));
+      final DocIdSetIterator conjunction = ConjunctionDISI.intersectScorers(Arrays.asList(iterators));
       assertEquals(intersect(sets), toBitSet(maxDoc, conjunction));
     }
   }
@@ -211,8 +211,8 @@ public class TestConjunctionDISI extends LuceneTestCase {
         }
       }
 
-      final ConjunctionDISI conjunction = ConjunctionDISI.intersectScorers(Arrays.asList(iterators));
-      TwoPhaseIterator twoPhaseIterator = conjunction.asTwoPhaseIterator();
+      final DocIdSetIterator conjunction = ConjunctionDISI.intersectScorers(Arrays.asList(iterators));
+      TwoPhaseIterator twoPhaseIterator = TwoPhaseIterator.unwrap(conjunction);
       assertEquals(hasApproximation, twoPhaseIterator != null);
       if (hasApproximation) {
         assertEquals(intersect(sets), toBitSet(maxDoc, TwoPhaseIterator.asDocIdSetIterator(twoPhaseIterator)));
@@ -248,8 +248,8 @@ public class TestConjunctionDISI extends LuceneTestCase {
         if (conjunction == null) {
           conjunction = newIterator;
         } else {
-          final ConjunctionDISI conj = ConjunctionDISI.intersectScorers(Arrays.asList(conjunction,
newIterator));
-          conjunction = scorer(conj, conj.asTwoPhaseIterator());
+          final DocIdSetIterator conj = ConjunctionDISI.intersectScorers(Arrays.asList(conjunction,
newIterator));
+          conjunction = scorer(conj, TwoPhaseIterator.unwrap(conj));
         }
       }
 
@@ -309,7 +309,7 @@ public class TestConjunctionDISI extends LuceneTestCase {
       }
 
 
-      final ConjunctionDISI conjunction = ConjunctionDISI.intersectScorers(scorers);
+      final DocIdSetIterator conjunction = ConjunctionDISI.intersectScorers(scorers);
       assertEquals(intersect(sets), toBitSet(maxDoc, conjunction));
     }
   }


Mime
View raw message