Java DocIdSetIterator.advance方法代码示例

import org.apache.lucene.search.DocIdSetIterator; //导入方法依赖的package包/类
private int doNext(int doc) throws IOException {
  int which=0;  // index of the iterator with the highest id
  int i=1;
  outer: for(;;) {
    for (; i<iterators.length; i++) {
      if (i == which) continue;
      DocIdSetIterator iter = iterators[i];
      int next = iter.advance(doc);
      if (next != doc) {
        doc = next;
        which = i;
        i = 0;
        continue outer;
      }
    }
    return doc;
  }
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入方法依赖的package包/类
@Override
public LeafBucketCollector getLeafCollector(final LeafReaderContext ctx, final LeafBucketCollector sub) throws IOException {
    IndexReaderContext topLevelContext = ReaderUtil.getTopLevelContext(ctx);
    IndexSearcher searcher = new IndexSearcher(topLevelContext);
    searcher.setQueryCache(null);
    Weight weight = searcher.createNormalizedWeight(childFilter, false);
    Scorer childDocsScorer = weight.scorer(ctx);

    final BitSet parentDocs = parentFilter.getBitSet(ctx);
    final DocIdSetIterator childDocs = childDocsScorer != null ? childDocsScorer.iterator() : null;
    return new LeafBucketCollectorBase(sub, null) {
        @Override
        public void collect(int parentDoc, long bucket) throws IOException {
            // if parentDoc is 0 then this means that this parent doesn't have child docs (b/c these appear always before the parent
            // doc), so we can skip:
            if (parentDoc == 0 || parentDocs == null || childDocs == null) {
                return;
            }

            final int prevParentDoc = parentDocs.prevSetBit(parentDoc - 1);
            int childDocId = childDocs.docID();
            if (childDocId <= prevParentDoc) {
                childDocId = childDocs.advance(prevParentDoc + 1);
            }

            for (; childDocId < parentDoc; childDocId = childDocs.nextDoc()) {
                collectBucket(sub, childDocId, bucket);
            }
        }
    };
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入方法依赖的package包/类
@Override
public DocIdSetIterator iterator() {
    final DocIdSetIterator in = scorer.iterator();
    return new DocIdSetIterator() {

        @Override
        public int advance(int target) throws IOException {
            profile.startTime(QueryTimingType.ADVANCE);
            try {
                return in.advance(target);
            } finally {
                profile.stopAndRecordTime();
            }
        }

        @Override
        public int nextDoc() throws IOException {
            profile.startTime(QueryTimingType.NEXT_DOC);
            try {
                return in.nextDoc();
            } finally {
                profile.stopAndRecordTime();
            }
        }

        @Override
        public int docID() {
            return in.docID();
        }

        @Override
        public long cost() {
            return in.cost();
        }
    };
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入方法依赖的package包/类
/** Does in-place AND of the bits provided by the
 *  iterator. */
public void and(DocIdSetIterator iter) throws IOException {
  if (iter instanceof OpenBitSetIterator && iter.docID() == -1) {
    final OpenBitSetIterator obs = (OpenBitSetIterator) iter;
    and(obs.arr, obs.words);
    // advance after last doc that would be accepted if standard
    // iteration is used (to exhaust it):
    obs.advance(numBits);
  } else if (iter instanceof FixedBitSetIterator && iter.docID() == -1) {
    final FixedBitSetIterator fbs = (FixedBitSetIterator) iter;
    and(fbs.bits, fbs.numWords);
    // advance after last doc that would be accepted if standard
    // iteration is used (to exhaust it):
    fbs.advance(numBits);
  } else {
    if (numBits == 0) return;
    int disiDoc, bitSetDoc = nextSetBit(0);
    while (bitSetDoc != -1 && (disiDoc = iter.advance(bitSetDoc)) < numBits) {
      clear(bitSetDoc, disiDoc);
      disiDoc++;
      bitSetDoc = (disiDoc < numBits) ? nextSetBit(disiDoc) : -1;
    }
    if (bitSetDoc != -1) {
      clear(bitSetDoc, numBits);
    }
  }
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入方法依赖的package包/类
/**
 * Perform an inplace AND with the doc ids from a given DocIdSetIterator,
 * leaving only the bits set for which the doc ids are in common.
 * These doc ids should be smaller than the maximum size passed to the
 * constructor.
 */   
public void inPlaceAnd(DocIdSetIterator disi) throws IOException {
  int bitSetDoc = nextSetBit(0);
  int disiDoc;
  while (bitSetDoc != -1 && (disiDoc = disi.advance(bitSetDoc)) != DocIdSetIterator.NO_MORE_DOCS) {
    clear(bitSetDoc, disiDoc);
    bitSetDoc = nextSetBit(disiDoc + 1);
  }
  if (bitSetDoc != -1) {
    clear(bitSetDoc, size());
  }
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入方法依赖的package包/类
@Override
public DocIdSetIterator iterator() {
    final DocIdSetIterator in = scorer.iterator();
    return new DocIdSetIterator() {
        
        @Override
        public int advance(int target) throws IOException {
            profile.startTime(ProfileBreakdown.TimingType.ADVANCE);
            try {
                return in.advance(target);
            } finally {
                profile.stopAndRecordTime();
            }
        }

        @Override
        public int nextDoc() throws IOException {
            profile.startTime(ProfileBreakdown.TimingType.NEXT_DOC);
            try {
                return in.nextDoc();
            } finally {
                profile.stopAndRecordTime();
            }
        }

        @Override
        public int docID() {
            return in.docID();
        }

        @Override
        public long cost() {
            return in.cost();
        }
    };
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入方法依赖的package包/类
private void advanceSubIterators(int target) throws IOException {
    if (target == NO_MORE_DOCS) {
        return;
    }
    for (DocIdSetIterator iterator: subIterators) {
        // FIXME: Probably inefficient
        if (iterator.docID() < target) {
            iterator.advance(target);
        }
    }
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入方法依赖的package包/类
void doIterate1(BitSet a, FixedBitSet b) throws IOException {
  int aa=-1,bb=-1;
  DocIdSetIterator iterator = b.iterator();
  do {
    aa = a.nextSetBit(aa+1);
    bb = (bb < b.length() && random().nextBoolean()) ? iterator.nextDoc() : iterator.advance(bb + 1);
    assertEquals(aa == -1 ? DocIdSetIterator.NO_MORE_DOCS : aa, bb);
  } while (aa>=0);
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入方法依赖的package包/类
void doIterate2(BitSet a, FixedBitSet b) throws IOException {
  int aa=-1,bb=-1;
  DocIdSetIterator iterator = b.iterator();
  do {
    aa = a.nextSetBit(aa+1);
    bb = random().nextBoolean() ? iterator.nextDoc() : iterator.advance(bb + 1);
    assertEquals(aa == -1 ? DocIdSetIterator.NO_MORE_DOCS : aa, bb);
  } while (aa>=0);
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入方法依赖的package包/类
public void doTestIteratorEqual(DocIdSet a, DocIdSet b) throws IOException {
  DocIdSetIterator ia = a.iterator();
  DocIdSetIterator ib = b.iterator();

  // test for next() equivalence
  for(;;) {
    int da = ia.nextDoc();
    int db = ib.nextDoc();
    assertEquals(da, db);
    assertEquals(ia.docID(), ib.docID());
    if (da==DocIdSetIterator.NO_MORE_DOCS) break;
  }

  for (int i=0; i<10; i++) {
    // test random skipTo() and next()
    ia = a.iterator();
    ib = b.iterator();
    int doc = -1;
    for (;;) {
      int da,db;
      if (rand.nextBoolean()) {
        da = ia.nextDoc();
        db = ib.nextDoc();
      } else {
        int target = doc + rand.nextInt(10) + 1;  // keep in mind future edge cases like probing (increase if necessary)
        da = ia.advance(target);
        db = ib.advance(target);
      }

      assertEquals(da, db);
      assertEquals(ia.docID(), ib.docID());
      if (da==DocIdSetIterator.NO_MORE_DOCS) break;
      doc = da;
    }
  }
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入方法依赖的package包/类
private SearchHit.NestedIdentity getInternalNestedIdentity(SearchContext context, int nestedSubDocId, LeafReaderContext subReaderContext, DocumentMapper documentMapper, ObjectMapper nestedObjectMapper) throws IOException {
    int currentParent = nestedSubDocId;
    ObjectMapper nestedParentObjectMapper;
    ObjectMapper current = nestedObjectMapper;
    String originalName = nestedObjectMapper.name();
    SearchHit.NestedIdentity nestedIdentity = null;
    do {
        Query parentFilter;
        nestedParentObjectMapper = documentMapper.findParentObjectMapper(current);
        if (nestedParentObjectMapper != null) {
            if (nestedParentObjectMapper.nested().isNested() == false) {
                current = nestedParentObjectMapper;
                continue;
            }
            parentFilter = nestedParentObjectMapper.nestedTypeFilter();
        } else {
            parentFilter = Queries.newNonNestedFilter();
        }

        Query childFilter = nestedObjectMapper.nestedTypeFilter();
        if (childFilter == null) {
            current = nestedParentObjectMapper;
            continue;
        }
        final Weight childWeight = context.searcher().createNormalizedWeight(childFilter, false);
        Scorer childScorer = childWeight.scorer(subReaderContext);
        if (childScorer == null) {
            current = nestedParentObjectMapper;
            continue;
        }
        DocIdSetIterator childIter = childScorer.iterator();

        BitSet parentBits = context.bitsetFilterCache().getBitSetProducer(parentFilter).getBitSet(subReaderContext);

        int offset = 0;
        int nextParent = parentBits.nextSetBit(currentParent);
        for (int docId = childIter.advance(currentParent + 1); docId < nextParent && docId != DocIdSetIterator.NO_MORE_DOCS; docId = childIter.nextDoc()) {
            offset++;
        }
        currentParent = nextParent;
        current = nestedObjectMapper = nestedParentObjectMapper;
        int currentPrefix = current == null ? 0 : current.name().length() + 1;
        nestedIdentity = new SearchHit.NestedIdentity(originalName.substring(currentPrefix), offset, nestedIdentity);
        if (current != null) {
            originalName = current.name();
        }
    } while (current != null);
    return nestedIdentity;
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入方法依赖的package包/类
@Override
public Weight createWeight(IndexSearcher searcher, boolean needsScores) throws IOException {
    final Weight childWeight = childFilter.createWeight(searcher, false);
    return new ConstantScoreWeight(this) {
        @Override
        public Scorer scorer(LeafReaderContext context) throws IOException {
            // Nested docs only reside in a single segment, so no need to evaluate all segments
            if (!context.reader().getCoreCacheKey().equals(leafReader.getCoreCacheKey())) {
                return null;
            }

            // If docId == 0 then we a parent doc doesn't have child docs, because child docs are stored
            // before the parent doc and because parent doc is 0 we can safely assume that there are no child docs.
            if (docId == 0) {
                return null;
            }

            final BitSet parents = parentFilter.getBitSet(context);
            final int firstChildDocId = parents.prevSetBit(docId - 1) + 1;
            // A parent doc doesn't have child docs, so we can early exit here:
            if (firstChildDocId == docId) {
                return null;
            }

            final Scorer childrenScorer = childWeight.scorer(context);
            if (childrenScorer == null) {
                return null;
            }
            DocIdSetIterator childrenIterator = childrenScorer.iterator();
            final DocIdSetIterator it = new DocIdSetIterator() {

                int doc = -1;

                @Override
                public int docID() {
                    return doc;
                }

                @Override
                public int nextDoc() throws IOException {
                    return advance(doc + 1);
                }

                @Override
                public int advance(int target) throws IOException {
                    target = Math.max(firstChildDocId, target);
                    if (target >= docId) {
                        // We're outside the child nested scope, so it is done
                        return doc = NO_MORE_DOCS;
                    } else {
                        int advanced = childrenIterator.advance(target);
                        if (advanced >= docId) {
                            // We're outside the child nested scope, so it is done
                            return doc = NO_MORE_DOCS;
                        } else {
                            return doc = advanced;
                        }
                    }
                }

                @Override
                public long cost() {
                    return Math.min(childrenIterator.cost(), docId - firstChildDocId);
                }

            };
            return new ConstantScoreScorer(this, score(), it);
        }
    };
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入方法依赖的package包/类
private InternalSearchHit.InternalNestedIdentity getInternalNestedIdentity(SearchContext context, int nestedSubDocId, LeafReaderContext subReaderContext, DocumentMapper documentMapper, ObjectMapper nestedObjectMapper) throws IOException {
    int currentParent = nestedSubDocId;
    ObjectMapper nestedParentObjectMapper;
    ObjectMapper current = nestedObjectMapper;
    String originalName = nestedObjectMapper.name();
    InternalSearchHit.InternalNestedIdentity nestedIdentity = null;
    do {
        Query parentFilter;
        nestedParentObjectMapper = documentMapper.findParentObjectMapper(current);
        if (nestedParentObjectMapper != null) {
            if (nestedParentObjectMapper.nested().isNested() == false) {
                current = nestedParentObjectMapper;
                continue;
            }
            parentFilter = nestedParentObjectMapper.nestedTypeFilter();
        } else {
            parentFilter = Queries.newNonNestedFilter();
        }

        Query childFilter = nestedObjectMapper.nestedTypeFilter();
        if (childFilter == null) {
            current = nestedParentObjectMapper;
            continue;
        }
        final Weight childWeight = context.searcher().createNormalizedWeight(childFilter, false);
        Scorer childScorer = childWeight.scorer(subReaderContext);
        if (childScorer == null) {
            current = nestedParentObjectMapper;
            continue;
        }
        DocIdSetIterator childIter = childScorer.iterator();

        BitSet parentBits = context.bitsetFilterCache().getBitSetProducer(parentFilter).getBitSet(subReaderContext);

        int offset = 0;
        int nextParent = parentBits.nextSetBit(currentParent);
        for (int docId = childIter.advance(currentParent + 1); docId < nextParent && docId != DocIdSetIterator.NO_MORE_DOCS; docId = childIter.nextDoc()) {
            offset++;
        }
        currentParent = nextParent;
        current = nestedObjectMapper = nestedParentObjectMapper;
        int currentPrefix = current == null ? 0 : current.name().length() + 1;
        nestedIdentity = new InternalSearchHit.InternalNestedIdentity(originalName.substring(currentPrefix), offset, nestedIdentity);
        if (current != null) {
            originalName = current.name();
        }
    } while (current != null);
    return nestedIdentity;
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入方法依赖的package包/类
/** Used when base query is highly constraining vs the
 *  drilldowns, or when the docs must be scored at once
 *  (i.e., like BooleanScorer2, not BooleanScorer).  In
 *  this case we just .next() on base and .advance() on
 *  the dim filters. */ 
private void doQueryFirstScoring(Collector collector, DocIdSetIterator[] disis, Collector[] sidewaysCollectors,
                                 Bits[] bits, Collector[] bitsSidewaysCollectors) throws IOException {
  //if (DEBUG) {
  //  System.out.println("  doQueryFirstScoring");
  //}
  int docID = baseScorer.docID();

  nextDoc: while (docID != DocsEnum.NO_MORE_DOCS) {
    Collector failedCollector = null;
    for (int i=0;i<disis.length;i++) {
      // TODO: should we sort this 2nd dimension of
      // docsEnums from most frequent to least?
      DocIdSetIterator disi = disis[i];
      if (disi != null && disi.docID() < docID) {
        disi.advance(docID);
      }
      if (disi == null || disi.docID() > docID) {
        if (failedCollector != null) {
          // More than one dim fails on this document, so
          // it's neither a hit nor a near-miss; move to
          // next doc:
          docID = baseScorer.nextDoc();
          continue nextDoc;
        } else {
          failedCollector = sidewaysCollectors[i];
        }
      }
    }

    // TODO: for the "non-costly Bits" we really should
    // have passed them down as acceptDocs, but
    // unfortunately we cannot distinguish today betwen
    // "bits() is so costly that you should apply it last"
    // from "bits() is so cheap that you should apply it
    // everywhere down low"

    // Fold in Filter Bits last, since they may be costly:
    for(int i=0;i<bits.length;i++) {
      if (bits[i].get(docID) == false) {
        if (failedCollector != null) {
          // More than one dim fails on this document, so
          // it's neither a hit nor a near-miss; move to
          // next doc:
          docID = baseScorer.nextDoc();
          continue nextDoc;
        } else {
          failedCollector = bitsSidewaysCollectors[i];
        }
      }
    }

    collectDocID = docID;

    // TODO: we could score on demand instead since we are
    // daat here:
    collectScore = baseScorer.score();

    if (failedCollector == null) {
      // Hit passed all filters, so it's "real":
      collectHit(collector, sidewaysCollectors, bitsSidewaysCollectors);
    } else {
      // Hit missed exactly one filter:
      collectNearMiss(failedCollector);
    }

    docID = baseScorer.nextDoc();
  }
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入方法依赖的package包/类
/**
 * Returns the set of document ids matching all queries.
 * This method is cache-aware and attempts to retrieve the answer from the cache if possible.
 * If the answer was not cached, it may have been inserted into the cache as a result of this call.
 * This method can handle negative queries.
 * <p>
 * The DocSet returned should <b>not</b> be modified.
 */
public DocSet getDocSet(List<Query> queries) throws IOException {

  if(queries != null) {
    for(Query q : queries) {
      if(q instanceof ScoreFilter) {
        return getDocSetScore(queries);
      }
    }
  }

  ProcessedFilter pf = getProcessedFilter(null, queries);
  if (pf.answer != null) return pf.answer;


  DocSetCollector setCollector = new DocSetCollector(maxDoc()>>6, maxDoc());
  Collector collector = setCollector;
  if (pf.postFilter != null) {
    pf.postFilter.setLastDelegate(collector);
    collector = pf.postFilter;
  }

  for (final AtomicReaderContext leaf : leafContexts) {
    final AtomicReader reader = leaf.reader();
    final Bits liveDocs = reader.getLiveDocs();   // TODO: the filter may already only have liveDocs...
    DocIdSet idSet = null;
    if (pf.filter != null) {
      idSet = pf.filter.getDocIdSet(leaf, liveDocs);
      if (idSet == null) continue;
    }
    DocIdSetIterator idIter = null;
    if (idSet != null) {
      idIter = idSet.iterator();
      if (idIter == null) continue;
    }

    collector.setNextReader(leaf);
    int max = reader.maxDoc();

    if (idIter == null) {
      for (int docid = 0; docid<max; docid++) {
        if (liveDocs != null && !liveDocs.get(docid)) continue;
        collector.collect(docid);
      }
    } else {
      for (int docid = -1; (docid = idIter.advance(docid+1)) < max; ) {
        collector.collect(docid);
      }
    }
  }

  if(collector instanceof DelegatingCollector) {
    ((DelegatingCollector) collector).finish();
  }

  return setCollector.getDocSet();
}