Java AtomicReader.maxDoc方法代码示例

import org.apache.lucene.index.AtomicReader; //导入方法依赖的package包/类
/** Merges in the stored fields from the readers in 
 *  <code>mergeState</code>. The default implementation skips
 *  over deleted documents, and uses {@link #startDocument()},
 *  {@link #writeField(FieldInfo, IndexableField)}, and {@link #finish(FieldInfos, int)},
 *  returning the number of documents that were written.
 *  Implementations can override this method for more sophisticated
 *  merging (bulk-byte copying, etc). */
public int merge(MergeState mergeState) throws IOException {
  int docCount = 0;
  for (AtomicReader reader : mergeState.readers) {
    final int maxDoc = reader.maxDoc();
    final Bits liveDocs = reader.getLiveDocs();
    for (int i = 0; i < maxDoc; i++) {
      if (liveDocs != null && !liveDocs.get(i)) {
        // skip deleted docs
        continue;
      }
      // TODO: this could be more efficient using
      // FieldVisitor instead of loading/writing entire
      // doc; ie we just have to renumber the field number
      // on the fly?
      // NOTE: it's very important to first assign to doc then pass it to
      // fieldsWriter.addDocument; see LUCENE-1282
      Document doc = reader.document(i);
      addDocument(doc, mergeState.fieldInfos);
      docCount++;
      mergeState.checkAbort.work(300);
    }
  }
  finish(mergeState.fieldInfos, docCount);
  return docCount;
}
 

import org.apache.lucene.index.AtomicReader; //导入方法依赖的package包/类
private int copyFieldsNoDeletions(MergeState mergeState, final AtomicReader reader,
                                  final Lucene40StoredFieldsReader matchingFieldsReader, int rawDocLengths[])
  throws IOException {
  final int maxDoc = reader.maxDoc();
  int docCount = 0;
  if (matchingFieldsReader != null) {
    // We can bulk-copy because the fieldInfos are "congruent"
    while (docCount < maxDoc) {
      int len = Math.min(MAX_RAW_MERGE_DOCS, maxDoc - docCount);
      IndexInput stream = matchingFieldsReader.rawDocs(rawDocLengths, docCount, len);
      addRawDocuments(stream, rawDocLengths, len);
      docCount += len;
      mergeState.checkAbort.work(300 * len);
    }
  } else {
    for (; docCount < maxDoc; docCount++) {
      // NOTE: it's very important to first assign to doc then pass it to
      // fieldsWriter.addDocument; see LUCENE-1282
      Document doc = reader.document(docCount);
      addDocument(doc, mergeState.fieldInfos);
      mergeState.checkAbort.work(300);
    }
  }
  return docCount;
}
 

import org.apache.lucene.index.AtomicReader; //导入方法依赖的package包/类
/** Merges in the term vectors from the readers in 
 *  <code>mergeState</code>. The default implementation skips
 *  over deleted documents, and uses {@link #startDocument(int)},
 *  {@link #startField(FieldInfo, int, boolean, boolean, boolean)}, 
 *  {@link #startTerm(BytesRef, int)}, {@link #addPosition(int, int, int, BytesRef)},
 *  and {@link #finish(FieldInfos, int)},
 *  returning the number of documents that were written.
 *  Implementations can override this method for more sophisticated
 *  merging (bulk-byte copying, etc). */
public int merge(MergeState mergeState) throws IOException {
  int docCount = 0;
  for (int i = 0; i < mergeState.readers.size(); i++) {
    final AtomicReader reader = mergeState.readers.get(i);
    final int maxDoc = reader.maxDoc();
    final Bits liveDocs = reader.getLiveDocs();

    for (int docID = 0; docID < maxDoc; docID++) {
      if (liveDocs != null && !liveDocs.get(docID)) {
        // skip deleted docs
        continue;
      }
      // NOTE: it's very important to first assign to vectors then pass it to
      // termVectorsWriter.addAllDocVectors; see LUCENE-1282
      Fields vectors = reader.getTermVectors(docID);
      addAllDocVectors(vectors, mergeState);
      docCount++;
      mergeState.checkAbort.work(300);
    }
  }
  finish(mergeState.fieldInfos, docCount);
  return docCount;
}
 

import org.apache.lucene.index.AtomicReader; //导入方法依赖的package包/类
private PackedLongValues getDeletes(List<AtomicReader> readers) {
  PackedLongValues.Builder deletes = PackedLongValues.monotonicBuilder(PackedInts.COMPACT);
  int deleteCount = 0;
  for (AtomicReader reader : readers) {
    final int maxDoc = reader.maxDoc();
    final Bits liveDocs = reader.getLiveDocs();
    for (int i = 0; i < maxDoc; ++i) {
      if (liveDocs != null && !liveDocs.get(i)) {
        ++deleteCount;
      } else {
        deletes.add(deleteCount);
      }
    }
  }
  return deletes.build();
}
 

import org.apache.lucene.index.AtomicReader; //导入方法依赖的package包/类
public void testReuseDocsEnumNoReuse() throws IOException {
  Directory dir = newDirectory();
  Codec cp = TestUtil.alwaysPostingsFormat(new Lucene40RWPostingsFormat());
  RandomIndexWriter writer = new RandomIndexWriter(random(), dir,
      newIndexWriterConfig(new MockAnalyzer(random())).setCodec(cp));
  int numdocs = atLeast(20);
  createRandomIndex(numdocs, writer, random());
  writer.commit();

  DirectoryReader open = DirectoryReader.open(dir);
  for (AtomicReaderContext ctx : open.leaves()) {
    AtomicReader indexReader = ctx.reader();
    Terms terms = indexReader.terms("body");
    TermsEnum iterator = terms.iterator(null);
    IdentityHashMap<DocsEnum, Boolean> enums = new IdentityHashMap<>();
    MatchNoBits bits = new Bits.MatchNoBits(indexReader.maxDoc());
    while ((iterator.next()) != null) {
      DocsEnum docs = iterator.docs(random().nextBoolean() ? bits : new Bits.MatchNoBits(indexReader.maxDoc()), null, random().nextBoolean() ? DocsEnum.FLAG_FREQS : DocsEnum.FLAG_NONE);
      enums.put(docs, true);
    }
    
    assertEquals(terms.size(), enums.size());
  }
  IOUtils.close(writer, open, dir);
}
 

import org.apache.lucene.index.AtomicReader; //导入方法依赖的package包/类
public void testBasics() throws Exception {
  // sanity check of norms writer
  // TODO: generalize
  AtomicReader slow = SlowCompositeReaderWrapper.wrap(reader);
  NumericDocValues fooNorms = slow.getNormValues("foo");
  NumericDocValues barNorms = slow.getNormValues("bar");
  for (int i = 0; i < slow.maxDoc(); i++) {
    assertFalse(fooNorms.get(i) == barNorms.get(i));
  }
  
  // sanity check of searching
  TopDocs foodocs = searcher.search(new TermQuery(new Term("foo", "brown")), 10);
  assertTrue(foodocs.totalHits > 0);
  TopDocs bardocs = searcher.search(new TermQuery(new Term("bar", "brown")), 10);
  assertTrue(bardocs.totalHits > 0);
  assertTrue(foodocs.scoreDocs[0].score < bardocs.scoreDocs[0].score);
}
 

import org.apache.lucene.index.AtomicReader; //导入方法依赖的package包/类
private int copyVectorsNoDeletions(MergeState mergeState,
                                    final Lucene40TermVectorsReader matchingVectorsReader,
                                    final AtomicReader reader,
                                    int rawDocLengths[],
                                    int rawDocLengths2[])
        throws IOException {
  final int maxDoc = reader.maxDoc();
  if (matchingVectorsReader != null) {
    // We can bulk-copy because the fieldInfos are "congruent"
    int docCount = 0;
    while (docCount < maxDoc) {
      int len = Math.min(MAX_RAW_MERGE_DOCS, maxDoc - docCount);
      matchingVectorsReader.rawDocs(rawDocLengths, rawDocLengths2, docCount, len);
      addRawDocuments(matchingVectorsReader, rawDocLengths, rawDocLengths2, len);
      docCount += len;
      mergeState.checkAbort.work(300 * len);
    }
  } else {
    for (int docNum = 0; docNum < maxDoc; docNum++) {
      // NOTE: it's very important to first assign to vectors then pass it to
      // termVectorsWriter.addAllDocVectors; see LUCENE-1282
      Fields vectors = reader.getTermVectors(docNum);
      addAllDocVectors(vectors, mergeState);
      mergeState.checkAbort.work(300);
    }
  }
  return maxDoc;
}
 

import org.apache.lucene.index.AtomicReader; //导入方法依赖的package包/类
public Bits getDocsWithField(AtomicReader reader, String field) throws IOException {
  final FieldInfo fieldInfo = reader.getFieldInfos().fieldInfo(field);
  if (fieldInfo == null) {
    // field does not exist or has no value
    return new Bits.MatchNoBits(reader.maxDoc());
  } else if (fieldInfo.hasDocValues()) {
    return reader.getDocsWithField(field);
  } else if (!fieldInfo.isIndexed()) {
    return new Bits.MatchNoBits(reader.maxDoc());
  }
  BitsEntry entry = (BitsEntry) caches.get(DocsWithFieldCache.class).get(reader, new CacheKey(field, null), false);
  return entry.bits;
}
 

import org.apache.lucene.index.AtomicReader; //导入方法依赖的package包/类
@Override
protected Accountable createValue(final AtomicReader reader, CacheKey key, boolean setDocsWithField)
    throws IOException {
  int maxDoc = reader.maxDoc();

  final int[][] matrix = new int[maxDoc][];
  BinaryDocValues valuesIn = reader.getBinaryDocValues(key.field);
  if (valuesIn == null) {
    for (int i = 0; i < maxDoc; ++i) {
      matrix[i] = new int[0];
    }
    return new IntList(matrix);
  }
  for (int i = 0; i < maxDoc; ++i) {
    String str = valuesIn.get(i).utf8ToString();
    if (StringUtils.isEmpty(str)) {
      matrix[i] = new int[0];
      continue;
    }
    JSONArray array = JSON.parseArray(str);
    matrix[i] = new int[array.size()];
    for (int j = 0; j < array.size(); ++j) {
      matrix[i][j] = array.getInteger(j);
    }
  }
  return new IntList(matrix);
}
 

import org.apache.lucene.index.AtomicReader; //导入方法依赖的package包/类
private FixedBitSet initialResult(AtomicReaderContext context, int logic, int[] index)
    throws IOException {
  AtomicReader reader = context.reader();
  FixedBitSet result = new FixedBitSet(reader.maxDoc());
  if (logic == AND) {
    result.or(getDISI(chain[index[0]], context));
    ++index[0];
  } else if (logic == ANDNOT) {
    result.or(getDISI(chain[index[0]], context));
    result.flip(0, reader.maxDoc()); // NOTE: may set bits for deleted docs.
    ++index[0];
  }
  return result;
}
 

import org.apache.lucene.index.AtomicReader; //导入方法依赖的package包/类
public BaseTermsEnumTraverser(AtomicReaderContext context, Bits acceptDocs) throws IOException {
  this.context = context;
  AtomicReader reader = context.reader();
  this.acceptDocs = acceptDocs;
  this.maxDoc = reader.maxDoc();
  Terms terms = reader.terms(fieldName);
  if (terms != null)
    this.termsEnum = terms.iterator(null);
}
 

import org.apache.lucene.index.AtomicReader; //导入方法依赖的package包/类
/**
 * Takes the categories from the given taxonomy directory, and adds the
 * missing ones to this taxonomy. Additionally, it fills the given
 * {@link OrdinalMap} with a mapping from the original ordinal to the new
 * ordinal.
 */
public void addTaxonomy(Directory taxoDir, OrdinalMap map) throws IOException {
  ensureOpen();
  DirectoryReader r = DirectoryReader.open(taxoDir);
  try {
    final int size = r.numDocs();
    final OrdinalMap ordinalMap = map;
    ordinalMap.setSize(size);
    int base = 0;
    TermsEnum te = null;
    DocsEnum docs = null;
    for (final AtomicReaderContext ctx : r.leaves()) {
      final AtomicReader ar = ctx.reader();
      final Terms terms = ar.terms(Consts.FULL);
      te = terms.iterator(te);
      while (te.next() != null) {
        FacetLabel cp = new FacetLabel(FacetsConfig.stringToPath(te.term().utf8ToString()));
        final int ordinal = addCategory(cp);
        docs = te.docs(null, docs, DocsEnum.FLAG_NONE);
        ordinalMap.addMapping(docs.nextDoc() + base, ordinal);
      }
      base += ar.maxDoc(); // no deletions, so we're ok
    }
    ordinalMap.addDone();
  } finally {
    r.close();
  }
}
 

import org.apache.lucene.index.AtomicReader; //导入方法依赖的package包/类
private int copyVectorsWithDeletions(MergeState mergeState,
                                      final Lucene40TermVectorsReader matchingVectorsReader,
                                      final AtomicReader reader,
                                      int rawDocLengths[],
                                      int rawDocLengths2[])
        throws IOException {
  final int maxDoc = reader.maxDoc();
  final Bits liveDocs = reader.getLiveDocs();
  int totalNumDocs = 0;
  if (matchingVectorsReader != null) {
    // We can bulk-copy because the fieldInfos are "congruent"
    for (int docNum = 0; docNum < maxDoc;) {
      if (!liveDocs.get(docNum)) {
        // skip deleted docs
        ++docNum;
        continue;
      }
      // We can optimize this case (doing a bulk byte copy) since the field
      // numbers are identical
      int start = docNum, numDocs = 0;
      do {
        docNum++;
        numDocs++;
        if (docNum >= maxDoc) break;
        if (!liveDocs.get(docNum)) {
          docNum++;
          break;
        }
      } while(numDocs < MAX_RAW_MERGE_DOCS);
      
      matchingVectorsReader.rawDocs(rawDocLengths, rawDocLengths2, start, numDocs);
      addRawDocuments(matchingVectorsReader, rawDocLengths, rawDocLengths2, numDocs);
      totalNumDocs += numDocs;
      mergeState.checkAbort.work(300 * numDocs);
    }
  } else {
    for (int docNum = 0; docNum < maxDoc; docNum++) {
      if (!liveDocs.get(docNum)) {
        // skip deleted docs
        continue;
      }
      
      // NOTE: it's very important to first assign to vectors then pass it to
      // termVectorsWriter.addAllDocVectors; see LUCENE-1282
      Fields vectors = reader.getTermVectors(docNum);
      addAllDocVectors(vectors, mergeState);
      totalNumDocs++;
      mergeState.checkAbort.work(300);
    }
  }
  return totalNumDocs;
}
 

import org.apache.lucene.index.AtomicReader; //导入方法依赖的package包/类
@Override
public int merge(MergeState mergeState) throws IOException {
  int docCount = 0;
  int idx = 0;

  for (AtomicReader reader : mergeState.readers) {
    final SegmentReader matchingSegmentReader = mergeState.matchingSegmentReaders[idx++];
    CompressingStoredFieldsReader matchingFieldsReader = null;
    if (matchingSegmentReader != null) {
      final StoredFieldsReader fieldsReader = matchingSegmentReader.getFieldsReader();
      // we can only bulk-copy if the matching reader is also a CompressingStoredFieldsReader
      if (fieldsReader != null && fieldsReader instanceof CompressingStoredFieldsReader) {
        matchingFieldsReader = (CompressingStoredFieldsReader) fieldsReader;
      }
    }

    final int maxDoc = reader.maxDoc();
    final Bits liveDocs = reader.getLiveDocs();

    if (matchingFieldsReader == null
        || matchingFieldsReader.getVersion() != VERSION_CURRENT // means reader version is not the same as the writer version
        || matchingFieldsReader.getCompressionMode() != compressionMode
        || matchingFieldsReader.getChunkSize() != chunkSize) { // the way data is decompressed depends on the chunk size
      // naive merge...
      for (int i = nextLiveDoc(0, liveDocs, maxDoc); i < maxDoc; i = nextLiveDoc(i + 1, liveDocs, maxDoc)) {
        Document doc = reader.document(i);
        addDocument(doc, mergeState.fieldInfos);
        ++docCount;
        mergeState.checkAbort.work(300);
      }
    } else {
      int docID = nextLiveDoc(0, liveDocs, maxDoc);
      if (docID < maxDoc) {
        // not all docs were deleted
        final ChunkIterator it = matchingFieldsReader.chunkIterator(docID);
        int[] startOffsets = new int[0];
        do {
          // go to the next chunk that contains docID
          it.next(docID);
          // transform lengths into offsets
          if (startOffsets.length < it.chunkDocs) {
            startOffsets = new int[ArrayUtil.oversize(it.chunkDocs, 4)];
          }
          for (int i = 1; i < it.chunkDocs; ++i) {
            startOffsets[i] = startOffsets[i - 1] + it.lengths[i - 1];
          }

          // decompress
          it.decompress();
          if (startOffsets[it.chunkDocs - 1] + it.lengths[it.chunkDocs - 1] != it.bytes.length) {
            throw new CorruptIndexException("Corrupted: expected chunk size=" + startOffsets[it.chunkDocs - 1] + it.lengths[it.chunkDocs - 1] + ", got " + it.bytes.length);
          }
          // copy non-deleted docs
          for (; docID < it.docBase + it.chunkDocs; docID = nextLiveDoc(docID + 1, liveDocs, maxDoc)) {
            final int diff = docID - it.docBase;
            startDocument();
            bufferedDocs.writeBytes(it.bytes.bytes, it.bytes.offset + startOffsets[diff], it.lengths[diff]);
            numStoredFieldsInDoc = it.numStoredFields[diff];
            finishDocument();
            ++docCount;
            mergeState.checkAbort.work(300);
          }
        } while (docID < maxDoc);

        it.checkIntegrity();
      }
    }
  }
  finish(mergeState.fieldInfos, docCount);
  return docCount;
}
 

import org.apache.lucene.index.AtomicReader; //导入方法依赖的package包/类
@Override
protected Accountable createValue(AtomicReader reader, CacheKey key, boolean setDocsWithField)
    throws IOException {

  int maxDoc = reader.maxDoc();
  final byte[] values;
  final ByteParser parser = (ByteParser) key.custom;
  if (parser == null) {
    // Confusing: must delegate to wrapper (vs simply
    // setting parser = DEFAULT_SHORT_PARSER) so cache
    // key includes DEFAULT_SHORT_PARSER:
    return (Accountable) wrapper.getBytes(reader, key.field, DEFAULT_BYTE_PARSER, setDocsWithField);
  }

  values = new byte[maxDoc];

  Uninvert u = new Uninvert() {
      private byte currentValue;

      @Override
      public void visitTerm(BytesRef term) {
        currentValue = parser.parseByte(term);
      }

      @Override
      public void visitDoc(int docID) {
        values[docID] = currentValue;
      }

      @Override
      protected TermsEnum termsEnum(Terms terms) throws IOException {
        return parser.termsEnum(terms);
      }
    };

  u.uninvert(reader, key.field, setDocsWithField);

  if (setDocsWithField) {
    wrapper.setDocsWithField(reader, key.field, u.docsWithField);
  }

  return new BytesFromArray(values);
}