Java IndexOptions.DOCS_AND_FREQS_AND_POSITIONS属性代码示例

void seek(TermInfo ti, Term term) throws IOException {
  count = 0;
  FieldInfo fi = fieldInfos.fieldInfo(term.field());
  this.indexOptions = (fi != null) ? fi.getIndexOptions() : IndexOptions.DOCS_AND_FREQS_AND_POSITIONS;
  currentFieldStoresPayloads = (fi != null) ? fi.hasPayloads() : false;
  if (ti == null) {
    df = 0;
  } else {
    df = ti.docFreq;
    doc = 0;
    freqBasePointer = ti.freqPointer;
    proxBasePointer = ti.proxPointer;
    skipPointer = freqBasePointer + ti.skipOffset;
    freqStream.seek(freqBasePointer);
    haveSkipped = false;
  }
}
 

@Override
public void startTerm() throws IOException {
  docIndex.mark();
  //System.out.println("SEPW: startTerm docIndex=" + docIndex);

  if (indexOptions != IndexOptions.DOCS_ONLY) {
    freqIndex.mark();
  }
  
  if (indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) {
    posIndex.mark();
    payloadStart = payloadOut.getFilePointer();
    lastPayloadLength = -1;
  }

  skipListWriter.resetSkip(docIndex, freqIndex, posIndex);
}
 

/**
 * Utility method to create a {@link org.apache.lucene.document.FieldType}
 * based on the {@link SchemaField}
 */
public static org.apache.lucene.document.FieldType createFieldType(SchemaField field) {
  if (!field.indexed() && !field.stored()) {
    if (log.isTraceEnabled())
      log.trace("Ignoring unindexed/unstored field: " + field);
    return null;
  }
  org.apache.lucene.document.FieldType newType = new org.apache.lucene.document.FieldType();
  newType.setIndexed(field.indexed());
  newType.setTokenized(field.isTokenized());
  newType.setStored(field.stored());
  newType.setOmitNorms(field.omitNorms());
  IndexOptions options = IndexOptions.DOCS_AND_FREQS_AND_POSITIONS;
  if (field.omitTermFreqAndPositions()) {
    options = IndexOptions.DOCS_ONLY;
  } else if (field.omitPositions()) {
    options = IndexOptions.DOCS_AND_FREQS;
  } else if (field.storeOffsetsWithPositions()) {
    options = IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS;
  }
  newType.setIndexOptions(options);
  newType.setStoreTermVectors(field.storeTermVector());
  newType.setStoreTermVectorOffsets(field.storeTermOffsets());
  newType.setStoreTermVectorPositions(field.storeTermPositions());
  return newType;
}
 

@Override
public DocsAndPositionsEnum docsAndPositions(Bits liveDocs, DocsAndPositionsEnum reuse, int flags) throws IOException {
  PreDocsAndPositionsEnum docsPosEnum;
  if (fieldInfo.getIndexOptions() != IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) {
    return null;
  } else if (reuse == null || !(reuse instanceof PreDocsAndPositionsEnum)) {
    docsPosEnum = new PreDocsAndPositionsEnum();
  } else {
    docsPosEnum = (PreDocsAndPositionsEnum) reuse;
    if (docsPosEnum.getFreqStream() != freqStream) {
      docsPosEnum = new PreDocsAndPositionsEnum();
    }
  }
  return docsPosEnum.reset(termEnum, liveDocs);        
}
 

public final int nextPosition() throws IOException {
  if (indexOptions != IndexOptions.DOCS_AND_FREQS_AND_POSITIONS)
    // This field does not store positions, payloads
    return 0;
  // perform lazy skips if necessary
  lazySkip();
  proxCount--;
  return position += readDeltaPosition();
}
 

@Override
public int setField(FieldInfo fieldInfo) {
  this.fieldInfo = fieldInfo;
  this.indexOptions = fieldInfo.getIndexOptions();
  if (indexOptions.compareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0) {
    throw new UnsupportedOperationException("this codec cannot index offsets");
  }
  skipListWriter.setIndexOptions(indexOptions);
  storePayloads = indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS && fieldInfo.hasPayloads();
  lastPayloadFP = 0;
  lastSkipFP = 0;
  lastState = setEmptyState();
  return 0;
}
 

private SepTermState setEmptyState() {
  SepTermState emptyState = new SepTermState();
  emptyState.docIndex = docOut.index();
  if (indexOptions != IndexOptions.DOCS_ONLY) {
    emptyState.freqIndex = freqOut.index();
    if (indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) {
      emptyState.posIndex = posOut.index();
    }
  }
  emptyState.payloadFP = 0;
  emptyState.skipFP = 0;
  return emptyState;
}
 

@Override
public void encodeTerm(long[] longs, DataOutput out, FieldInfo fieldInfo, BlockTermState _state, boolean absolute) throws IOException {
  SepTermState state = (SepTermState)_state;
  if (absolute) {
    lastSkipFP = 0;
    lastPayloadFP = 0;
    lastState = state;
  }
  lastState.docIndex.copyFrom(state.docIndex, false);
  lastState.docIndex.write(out, absolute);
  if (indexOptions != IndexOptions.DOCS_ONLY) {
    lastState.freqIndex.copyFrom(state.freqIndex, false);
    lastState.freqIndex.write(out, absolute);
    if (indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) {
      lastState.posIndex.copyFrom(state.posIndex, false);
      lastState.posIndex.write(out, absolute);
      if (storePayloads) {
        if (absolute) {
          out.writeVLong(state.payloadFP);
        } else {
          out.writeVLong(state.payloadFP - lastPayloadFP);
        }
        lastPayloadFP = state.payloadFP;
      }
    }
  }
  if (state.skipFP != -1) {
    if (absolute) {
      out.writeVLong(state.skipFP);
    } else {
      out.writeVLong(state.skipFP - lastSkipFP);
    }
    lastSkipFP = state.skipFP;
  }
}
 

@Override
public void decodeTerm(long[] empty, DataInput in, FieldInfo fieldInfo, BlockTermState _termState, boolean absolute) 
  throws IOException {
  final SepTermState termState = (SepTermState) _termState;
  termState.docIndex.read(in, absolute);
  if (fieldInfo.getIndexOptions() != IndexOptions.DOCS_ONLY) {
    termState.freqIndex.read(in, absolute);
    if (fieldInfo.getIndexOptions() == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) {
      //System.out.println("  freqIndex=" + termState.freqIndex);
      termState.posIndex.read(in, absolute);
      //System.out.println("  posIndex=" + termState.posIndex);
      if (fieldInfo.hasPayloads()) {
        if (absolute) {
          termState.payloadFP = in.readVLong();
        } else {
          termState.payloadFP += in.readVLong();
        }
        //System.out.println("  payloadFP=" + termState.payloadFP);
      }
    }
  }

  if (termState.docFreq >= skipMinimum) {
    //System.out.println("   readSkip @ " + in.getPosition());
    if (absolute) {
      termState.skipFP = in.readVLong();
    } else {
      termState.skipFP += in.readVLong();
    }
    //System.out.println("  skipFP=" + termState.skipFP);
  } else if (absolute) {
    termState.skipFP = 0;
  }
}
 

IndexOptions indexOptions() {
  switch(random().nextInt(4)) {
    case 0: return IndexOptions.DOCS_ONLY;
    case 1: return IndexOptions.DOCS_AND_FREQS;
    case 2: return IndexOptions.DOCS_AND_FREQS_AND_POSITIONS;
    default: return IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS;
  }
}
 

protected IndexOptions getIndexOptions(SchemaField field, String internalVal) {

    IndexOptions options = IndexOptions.DOCS_AND_FREQS_AND_POSITIONS;
    if (field.omitTermFreqAndPositions()) {
      options = IndexOptions.DOCS_ONLY;
    } else if (field.omitPositions()) {
      options = IndexOptions.DOCS_AND_FREQS;
    } else if (field.storeOffsetsWithPositions()) {
      options = IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS;
    }

    return options;
  }
 

@Override
public FieldInfos read(Directory directory, String segmentName, String segmentSuffix, IOContext iocontext) throws IOException {
  final String fileName = IndexFileNames.segmentFileName(segmentName, "", Lucene40FieldInfosFormat.FIELD_INFOS_EXTENSION);
  IndexInput input = directory.openInput(fileName, iocontext);
  
  boolean success = false;
  try {
    CodecUtil.checkHeader(input, Lucene40FieldInfosFormat.CODEC_NAME, 
                                 Lucene40FieldInfosFormat.FORMAT_START, 
                                 Lucene40FieldInfosFormat.FORMAT_CURRENT);

    final int size = input.readVInt(); //read in the size
    FieldInfo infos[] = new FieldInfo[size];

    for (int i = 0; i < size; i++) {
      String name = input.readString();
      final int fieldNumber = input.readVInt();
      byte bits = input.readByte();
      boolean isIndexed = (bits & Lucene40FieldInfosFormat.IS_INDEXED) != 0;
      boolean storeTermVector = (bits & Lucene40FieldInfosFormat.STORE_TERMVECTOR) != 0;
      boolean omitNorms = (bits & Lucene40FieldInfosFormat.OMIT_NORMS) != 0;
      boolean storePayloads = (bits & Lucene40FieldInfosFormat.STORE_PAYLOADS) != 0;
      final IndexOptions indexOptions;
      if (!isIndexed) {
        indexOptions = null;
      } else if ((bits & Lucene40FieldInfosFormat.OMIT_TERM_FREQ_AND_POSITIONS) != 0) {
        indexOptions = IndexOptions.DOCS_ONLY;
      } else if ((bits & Lucene40FieldInfosFormat.OMIT_POSITIONS) != 0) {
        indexOptions = IndexOptions.DOCS_AND_FREQS;
      } else if ((bits & Lucene40FieldInfosFormat.STORE_OFFSETS_IN_POSTINGS) != 0) {
        indexOptions = IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS;
      } else {
        indexOptions = IndexOptions.DOCS_AND_FREQS_AND_POSITIONS;
      }

      // LUCENE-3027: past indices were able to write
      // storePayloads=true when omitTFAP is also true,
      // which is invalid.  We correct that, here:
      if (isIndexed && indexOptions.compareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) < 0) {
        storePayloads = false;
      }
      // DV Types are packed in one byte
      byte val = input.readByte();
      final LegacyDocValuesType oldValuesType = getDocValuesType((byte) (val & 0x0F));
      final LegacyDocValuesType oldNormsType = getDocValuesType((byte) ((val >>> 4) & 0x0F));
      final Map<String,String> attributes = input.readStringStringMap();;
      if (oldValuesType.mapping != null) {
        attributes.put(LEGACY_DV_TYPE_KEY, oldValuesType.name());
      }
      if (oldNormsType.mapping != null) {
        if (oldNormsType.mapping != DocValuesType.NUMERIC) {
          throw new CorruptIndexException("invalid norm type: " + oldNormsType + " (resource=" + input + ")");
        }
        attributes.put(LEGACY_NORM_TYPE_KEY, oldNormsType.name());
      }
      infos[i] = new FieldInfo(name, isIndexed, fieldNumber, storeTermVector, 
        omitNorms, storePayloads, indexOptions, oldValuesType.mapping, oldNormsType.mapping, -1, Collections.unmodifiableMap(attributes));
    }

    CodecUtil.checkEOF(input);
    FieldInfos fieldInfos = new FieldInfos(infos);
    success = true;
    return fieldInfos;
  } finally {
    if (success) {
      input.close();
    } else {
      IOUtils.closeWhileHandlingException(input);
    }
  }
}
 

@Override
public FieldInfos read(Directory directory, String segmentName, String segmentSuffix, IOContext context) throws IOException {
  final String fileName = IndexFileNames.segmentFileName(segmentName, segmentSuffix, Lucene46FieldInfosFormat.EXTENSION);
  ChecksumIndexInput input = directory.openChecksumInput(fileName, context);
  
  boolean success = false;
  try {
    int codecVersion = CodecUtil.checkHeader(input, Lucene46FieldInfosFormat.CODEC_NAME, 
                                                    Lucene46FieldInfosFormat.FORMAT_START, 
                                                    Lucene46FieldInfosFormat.FORMAT_CURRENT);

    final int size = input.readVInt(); //read in the size
    FieldInfo infos[] = new FieldInfo[size];

    for (int i = 0; i < size; i++) {
      String name = input.readString();
      final int fieldNumber = input.readVInt();
      if (fieldNumber < 0) {
        throw new CorruptIndexException("invalid field number for field: " + name + ", fieldNumber=" + fieldNumber + " (resource=" + input + ")");
      }
      byte bits = input.readByte();
      boolean isIndexed = (bits & Lucene46FieldInfosFormat.IS_INDEXED) != 0;
      boolean storeTermVector = (bits & Lucene46FieldInfosFormat.STORE_TERMVECTOR) != 0;
      boolean omitNorms = (bits & Lucene46FieldInfosFormat.OMIT_NORMS) != 0;
      boolean storePayloads = (bits & Lucene46FieldInfosFormat.STORE_PAYLOADS) != 0;
      final IndexOptions indexOptions;
      if (!isIndexed) {
        indexOptions = null;
      } else if ((bits & Lucene46FieldInfosFormat.OMIT_TERM_FREQ_AND_POSITIONS) != 0) {
        indexOptions = IndexOptions.DOCS_ONLY;
      } else if ((bits & Lucene46FieldInfosFormat.OMIT_POSITIONS) != 0) {
        indexOptions = IndexOptions.DOCS_AND_FREQS;
      } else if ((bits & Lucene46FieldInfosFormat.STORE_OFFSETS_IN_POSTINGS) != 0) {
        indexOptions = IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS;
      } else {
        indexOptions = IndexOptions.DOCS_AND_FREQS_AND_POSITIONS;
      }

      // DV Types are packed in one byte
      byte val = input.readByte();
      final DocValuesType docValuesType = getDocValuesType(input, (byte) (val & 0x0F));
      final DocValuesType normsType = getDocValuesType(input, (byte) ((val >>> 4) & 0x0F));
      final long dvGen = input.readLong();
      final Map<String,String> attributes = input.readStringStringMap();
      infos[i] = new FieldInfo(name, isIndexed, fieldNumber, storeTermVector, 
        omitNorms, storePayloads, indexOptions, docValuesType, normsType, dvGen, Collections.unmodifiableMap(attributes));
    }
    
    if (codecVersion >= Lucene46FieldInfosFormat.FORMAT_CHECKSUM) {
      CodecUtil.checkFooter(input);
    } else {
      CodecUtil.checkEOF(input);
    }
    FieldInfos fieldInfos = new FieldInfos(infos);
    success = true;
    return fieldInfos;
  } finally {
    if (success) {
      input.close();
    } else {
      IOUtils.closeWhileHandlingException(input);
    }
  }
}
 

public Lucene3xFields(Directory dir, FieldInfos fieldInfos, SegmentInfo info, IOContext context, int indexDivisor)
  throws IOException {

  si = info;

  // NOTE: we must always load terms index, even for
  // "sequential" scan during merging, because what is
  // sequential to merger may not be to TermInfosReader
  // since we do the surrogates dance:
  if (indexDivisor < 0) {
    indexDivisor = -indexDivisor;
  }
  
  boolean success = false;
  try {
    TermInfosReader r = newTermInfosReader(dir, info.name, fieldInfos, context, indexDivisor);    
    if (indexDivisor == -1) {
      tisNoIndex = r;
    } else {
      tisNoIndex = null;
      tis = r;
    }
    this.context = context;
    this.fieldInfos = fieldInfos;

    // make sure that all index files have been read or are kept open
    // so that if an index update removes them we'll still have them
    freqStream = dir.openInput(IndexFileNames.segmentFileName(info.name, "", Lucene3xPostingsFormat.FREQ_EXTENSION), context);
    boolean anyProx = false;
    for (FieldInfo fi : fieldInfos) {
      if (fi.isIndexed()) {
        fields.put(fi.name, fi);
        preTerms.put(fi.name, new PreTerms(fi));
        if (fi.getIndexOptions() == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) {
          anyProx = true;
        }
      }
    }

    if (anyProx) {
      proxStream = dir.openInput(IndexFileNames.segmentFileName(info.name, "", Lucene3xPostingsFormat.PROX_EXTENSION), context);
    } else {
      proxStream = null;
    }
    success = true;
  } finally {
    // With lock-less commits, it's entirely possible (and
    // fine) to hit a FileNotFound exception above. In
    // this case, we want to explicitly close any subset
    // of things that were opened so that we don't have to
    // wait for a GC to do so.
    if (!success) {
      close();
    }
  }
  this.dir = dir;
}
 

@Override
public FieldInfos read(Directory directory, String segmentName, String segmentSuffix, IOContext iocontext) throws IOException {
  final String fileName = IndexFileNames.segmentFileName(segmentName, "", FIELD_INFOS_EXTENSION);
  IndexInput input = directory.openInput(fileName, iocontext);
  
  boolean success = false;
  try {
    final int format = input.readVInt();

    if (format > FORMAT_MINIMUM) {
      throw new IndexFormatTooOldException(input, format, FORMAT_MINIMUM, FORMAT_CURRENT);
    }
    if (format < FORMAT_CURRENT) {
      throw new IndexFormatTooNewException(input, format, FORMAT_MINIMUM, FORMAT_CURRENT);
    }

    final int size = input.readVInt(); //read in the size
    FieldInfo infos[] = new FieldInfo[size];

    for (int i = 0; i < size; i++) {
      String name = input.readString();
      final int fieldNumber = i;
      byte bits = input.readByte();
      boolean isIndexed = (bits & IS_INDEXED) != 0;
      boolean storeTermVector = (bits & STORE_TERMVECTOR) != 0;
      boolean omitNorms = (bits & OMIT_NORMS) != 0;
      boolean storePayloads = (bits & STORE_PAYLOADS) != 0;
      final IndexOptions indexOptions;
      if (!isIndexed) {
        indexOptions = null;
      } else if ((bits & OMIT_TERM_FREQ_AND_POSITIONS) != 0) {
        indexOptions = IndexOptions.DOCS_ONLY;
      } else if ((bits & OMIT_POSITIONS) != 0) {
        if (format <= FORMAT_OMIT_POSITIONS) {
          indexOptions = IndexOptions.DOCS_AND_FREQS;
        } else {
          throw new CorruptIndexException("Corrupt fieldinfos, OMIT_POSITIONS set but format=" + format + " (resource: " + input + ")");
        }
      } else {
        indexOptions = IndexOptions.DOCS_AND_FREQS_AND_POSITIONS;
      }

      // LUCENE-3027: past indices were able to write
      // storePayloads=true when omitTFAP is also true,
      // which is invalid.  We correct that, here:
      if (indexOptions != IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) {
        storePayloads = false;
      }
      infos[i] = new FieldInfo(name, isIndexed, fieldNumber, storeTermVector, 
        omitNorms, storePayloads, indexOptions, null, isIndexed && !omitNorms? DocValuesType.NUMERIC : null, -1, Collections.<String,String>emptyMap());
    }

    if (input.getFilePointer() != input.length()) {
      throw new CorruptIndexException("did not read all bytes from file \"" + fileName + "\": read " + input.getFilePointer() + " vs size " + input.length() + " (resource: " + input + ")");
    }
    FieldInfos fieldInfos = new FieldInfos(infos);
    success = true;
    return fieldInfos;
  } finally {
    if (success) {
      input.close();
    } else {
      IOUtils.closeWhileHandlingException(input);
    }
  }
}