Java DocIdSetIterator类代码示例

import org.apache.lucene.search.DocIdSetIterator; //导入依赖的package包/类
/**
 * This method iterates all terms in the given {@link TermsEnum} and
 * associates each terms ordinal with the terms documents. The caller must
 * exhaust the returned {@link BytesRefIterator} which returns all values
 * where the first returned value is associated with the ordinal <tt>1</tt>
 * etc.
 * <p>
 * If the {@link TermsEnum} contains prefix coded numerical values the terms
 * enum should be wrapped with either {@link #wrapNumeric32Bit(TermsEnum)}
 * or {@link #wrapNumeric64Bit(TermsEnum)} depending on its precision. If
 * the {@link TermsEnum} is not wrapped the returned
 * {@link BytesRefIterator} will contain partial precision terms rather than
 * only full-precision terms.
 * </p>
 */
public BytesRefIterator buildFromTerms(final TermsEnum termsEnum) throws IOException {
    return new BytesRefIterator() {
        private PostingsEnum docsEnum = null;

        @Override
        public BytesRef next() throws IOException {
            BytesRef ref;
            if ((ref = termsEnum.next()) != null) {
                docsEnum = termsEnum.postings(docsEnum, PostingsEnum.NONE);
                nextOrdinal();
                int docId;
                while ((docId = docsEnum.nextDoc()) != DocIdSetIterator.NO_MORE_DOCS) {
                    addDoc(docId);
                }
            }
            return ref;
        }
    };
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入依赖的package包/类
@Override
public TwoPhaseIterator twoPhaseIterator() {
    final TwoPhaseIterator inTwoPhase = this.in.twoPhaseIterator();
    final DocIdSetIterator approximation = inTwoPhase == null ? in.iterator() : inTwoPhase.approximation();
    return new TwoPhaseIterator(approximation) {

        @Override
        public boolean matches() throws IOException {
            // we need to check the two-phase iterator first
            // otherwise calling score() is illegal
            if (inTwoPhase != null && inTwoPhase.matches() == false) {
                return false;
            }
            return in.score() >= minScore;
        }

        @Override
        public float matchCost() {
            return 1000f // random constant for the score computation
                    + (inTwoPhase == null ? 0 : inTwoPhase.matchCost());
        }
    };
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入依赖的package包/类
/** Return null if id is not found. */
public DocIdAndVersion lookup(BytesRef id, Bits liveDocs, LeafReaderContext context) throws IOException {
    if (termsEnum.seekExact(id)) {
        // there may be more than one matching docID, in the case of nested docs, so we want the last one:
        docsEnum = termsEnum.postings(docsEnum, 0);
        int docID = DocIdSetIterator.NO_MORE_DOCS;
        for (int d = docsEnum.nextDoc(); d != DocIdSetIterator.NO_MORE_DOCS; d = docsEnum.nextDoc()) {
            if (liveDocs != null && liveDocs.get(d) == false) {
                continue;
            }
            docID = d;
        }

        if (docID != DocIdSetIterator.NO_MORE_DOCS) {
            return new DocIdAndVersion(docID, versions.get(docID), context);
        }
    }

    return null;
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入依赖的package包/类
/**
 * Check whether there is one or more documents matching the provided query.
 */
public static boolean exists(IndexSearcher searcher, Query query) throws IOException {
    final Weight weight = searcher.createNormalizedWeight(query, false);
    // the scorer API should be more efficient at stopping after the first
    // match than the bulk scorer API
    for (LeafReaderContext context : searcher.getIndexReader().leaves()) {
        final Scorer scorer = weight.scorer(context);
        if (scorer == null) {
            continue;
        }
        final Bits liveDocs = context.reader().getLiveDocs();
        final DocIdSetIterator iterator = scorer.iterator();
        for (int doc = iterator.nextDoc(); doc != DocIdSetIterator.NO_MORE_DOCS; doc = iterator.nextDoc()) {
            if (liveDocs == null || liveDocs.get(doc)) {
                return true;
            }
        }
    }
    return false;
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入依赖的package包/类
/**
 * Return a Scorer that throws an ElasticsearchIllegalStateException
 * on all operations with the given message.
 */
public static Scorer illegalScorer(final String message) {
    return new Scorer(null) {
        @Override
        public float score() throws IOException {
            throw new IllegalStateException(message);
        }
        @Override
        public int freq() throws IOException {
            throw new IllegalStateException(message);
        }
        @Override
        public int docID() {
            throw new IllegalStateException(message);
        }
        @Override
        public DocIdSetIterator iterator() {
            throw new IllegalStateException(message);
        }
    };
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入依赖的package包/类
SeqSpanScorer(SeqSpanWeight weight, PostingsAndFreq[] postings,
                  Similarity.SimScorer docScorer, boolean needsScores,
                  float matchCost) throws IOException {
  super(weight);
  this.selfWeight = weight;
  this.docScorer = docScorer;
  this.needsScores = needsScores;

  List<DocIdSetIterator> iterators = new ArrayList<>();
  List<PostingsAndPosition> postingsAndPositions = new ArrayList<>();
  for(PostingsAndFreq posting : postings) {
    iterators.add(posting.postings);
    postingsAndPositions.add(new PostingsAndPosition(posting.postings, posting.position));
  }
  conjunction = ConjunctionDISI.intersectIterators(iterators);
  this.postings = postingsAndPositions.toArray(new PostingsAndPosition[postingsAndPositions.size()]);
  this.matchCost = matchCost;
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入依赖的package包/类
@Override
public boolean next() throws IOException {
  if (count == freq) {
    if (postings == null) {
      return false;
    }
    doc = postings.nextDoc();
    if (doc == DocIdSetIterator.NO_MORE_DOCS) {
      return false;
    }
    freq = postings.freq();
    count = 0;
  }
  position = postings.nextPosition();
  count++;
  readPayload = false;
  return true;
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入依赖的package包/类
@Override
int nextDoc() {
  if (idx >= size) {
    offset = -1;
    return doc = DocIdSetIterator.NO_MORE_DOCS;
  }
  doc = (int) docs.get(idx);
  ++idx;
  while (idx < size && docs.get(idx) == doc) {
    ++idx;
  }
  // idx points to the "next" element
  long prevIdx = idx - 1;
  // cannot change 'value' here because nextDoc is called before the
  // value is used, and it's a waste to clone the BytesRef when we
  // obtain the value
  offset = (int) offsets.get(prevIdx);
  length = (int) lengths.get(prevIdx);
  return doc;
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入依赖的package包/类
/** Does in-place OR of the bits provided by the
 *  iterator. */
public void or(DocIdSetIterator iter) throws IOException {
  if (iter instanceof OpenBitSetIterator && iter.docID() == -1) {
    final OpenBitSetIterator obs = (OpenBitSetIterator) iter;
    or(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;
    or(fbs.bits, fbs.numWords);
    // advance after last doc that would be accepted if standard
    // iteration is used (to exhaust it):
    fbs.advance(numBits);
  } else {
    int doc;
    while ((doc = iter.nextDoc()) < numBits) {
      set(doc);
    }
  }
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入依赖的package包/类
/** Does in-place AND NOT of the bits provided by the
 *  iterator. */
public void andNot(DocIdSetIterator iter) throws IOException {
  if (iter instanceof OpenBitSetIterator && iter.docID() == -1) {
    final OpenBitSetIterator obs = (OpenBitSetIterator) iter;
    andNot(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;
    andNot(fbs.bits, fbs.numWords);
    // advance after last doc that would be accepted if standard
    // iteration is used (to exhaust it):
    fbs.advance(numBits);
  } else {
    int doc;
    while ((doc = iter.nextDoc()) < numBits) {
      clear(doc);
    }
  }
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入依赖的package包/类
/**
 * This method iterates all terms in the given {@link TermsEnum} and
 * associates each terms ordinal with the terms documents. The caller must
 * exhaust the returned {@link BytesRefIterator} which returns all values
 * where the first returned value is associted with the ordinal <tt>1</tt>
 * etc.
 * <p>
 * If the {@link TermsEnum} contains prefix coded numerical values the terms
 * enum should be wrapped with either {@link #wrapNumeric32Bit(TermsEnum)}
 * or {@link #wrapNumeric64Bit(TermsEnum)} depending on its precision. If
 * the {@link TermsEnum} is not wrapped the returned
 * {@link BytesRefIterator} will contain partial precision terms rather than
 * only full-precision terms.
 * </p>
 */
public BytesRefIterator buildFromTerms(final TermsEnum termsEnum) throws IOException {
    return new BytesRefIterator() {
        private PostingsEnum docsEnum = null;

        @Override
        public BytesRef next() throws IOException {
            BytesRef ref;
            if ((ref = termsEnum.next()) != null) {
                docsEnum = termsEnum.postings(docsEnum, PostingsEnum.NONE);
                nextOrdinal();
                int docId;
                while ((docId = docsEnum.nextDoc()) != DocIdSetIterator.NO_MORE_DOCS) {
                    addDoc(docId);
                }
            }
            return ref;
        }
    };
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入依赖的package包/类
@Override
public Scorer scorer(LeafReaderContext context) throws IOException {
    final Scorer parentScorer = parentWeight.scorer(context);

    // no matches
    if (parentScorer == null) {
        return null;
    }

    BitSet parents = parentsFilter.getBitSet(context);
    if (parents == null) {
        // No matches
        return null;
    }

    int firstParentDoc = parentScorer.iterator().nextDoc();
    if (firstParentDoc == DocIdSetIterator.NO_MORE_DOCS) {
        // No matches
        return null;
    }
    return new IncludeNestedDocsScorer(this, parentScorer, parents, firstParentDoc);
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入依赖的package包/类
@Override
public Scorer scorer(LeafReaderContext context) throws IOException {
    DocIdSet childrenDocSet = childrenFilter.getDocIdSet(context, null);
    // we forcefully apply live docs here so that deleted children don't give matching parents
    childrenDocSet = BitsFilteredDocIdSet.wrap(childrenDocSet, context.reader().getLiveDocs());
    if (Lucene.isEmpty(childrenDocSet)) {
        return null;
    }
    final DocIdSetIterator childIterator = childrenDocSet.iterator();
    if (childIterator == null) {
        return null;
    }
    SortedDocValues bytesValues = globalIfd.load(context).getOrdinalsValues(parentType);
    if (bytesValues == null) {
        return null;
    }

    return new ChildScorer(this, parentIdxs, scores, childIterator, bytesValues);
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入依赖的package包/类
@Override
public Scorer scorer(LeafReaderContext context) throws IOException {
    DocIdSet childrenDocIdSet = childrenFilter.getDocIdSet(context, null);
    if (Lucene.isEmpty(childrenDocIdSet)) {
        return null;
    }

    SortedDocValues globalValues = globalIfd.load(context).getOrdinalsValues(parentType);
    if (globalValues != null) {
        // we forcefully apply live docs here so that deleted children don't give matching parents
        childrenDocIdSet = BitsFilteredDocIdSet.wrap(childrenDocIdSet, context.reader().getLiveDocs());
        DocIdSetIterator innerIterator = childrenDocIdSet.iterator();
        if (innerIterator != null) {
            ChildrenDocIdIterator childrenDocIdIterator = new ChildrenDocIdIterator(
                    innerIterator, parentOrds, globalValues
            );
            return ConstantScorer.create(childrenDocIdIterator, this, queryWeight);
        }
    }
    return null;
}
 

import org.apache.lucene.search.DocIdSetIterator; //导入依赖的package包/类
/**
 * Tests only with a single empty <code>{@link PostingsEnumMock}</code> as basis for the <code>{@link MultiDocIdSetIterator}</code>
 */
@Test
public void test_SingleEmpty() throws IOException {

    // arrange
    PostingsEnumMock mainPostings = new PostingsEnumMock(new int[0], new int[0]);

    MultiDocIdSetIterator postingsEnum = new MultiDocIdSetIterator(
            new PostingsEnumWeightTuple[]{
                    new PostingsEnumWeightTuple(mainPostings,0)
            });

    // act + assert
    postingsEnum.nextDoc();
    Assert.assertEquals(DocIdSetIterator.NO_MORE_DOCS, postingsEnum.docID());
    Assert.assertEquals(DocIdSetIterator.NO_MORE_DOCS, mainPostings.docID());
}