Java Context.MERGE属性代码示例

@Override
public IndexOutput createOutput(String name, IOContext context) throws IOException {
    final IndexOutput output = in.createOutput(name, context);

    StoreRateLimiting rateLimiting = rateLimitingProvider.rateLimiting();
    StoreRateLimiting.Type type = rateLimiting.getType();
    RateLimiter limiter = rateLimiting.getRateLimiter();
    if (type == StoreRateLimiting.Type.NONE || limiter == null) {
        return output;
    }
    if (context.context == Context.MERGE || type == StoreRateLimiting.Type.ALL) {
        // we are merging, and type is either MERGE or ALL, rate limit...
        return new RateLimitedIndexOutput(new RateLimiterWrapper(limiter, rateListener), output);
    }
    // we shouldn't really get here...
    return output;
}
 

public CompletionFieldsProducer(SegmentReadState state) throws IOException {
    String suggestFSTFile = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, EXTENSION);
    IndexInput input = state.directory.openInput(suggestFSTFile, state.context);
    version = CodecUtil.checkHeader(input, CODEC_NAME, SUGGEST_CODEC_VERSION, SUGGEST_VERSION_CURRENT);
    FieldsProducer delegateProducer = null;
    boolean success = false;
    try {
        PostingsFormat delegatePostingsFormat = PostingsFormat.forName(input.readString());
        String providerName = input.readString();
        CompletionLookupProvider completionLookupProvider = providers.get(providerName);
        if (completionLookupProvider == null) {
            throw new IllegalStateException("no provider with name [" + providerName + "] registered");
        }
        // TODO: we could clone the ReadState and make it always forward IOContext.MERGE to prevent unecessary heap usage?
        delegateProducer = delegatePostingsFormat.fieldsProducer(state);
        /*
         * If we are merging we don't load the FSTs at all such that we
         * don't consume so much memory during merge
         */
        if (state.context.context != Context.MERGE) {
            // TODO: maybe we can do this in a fully lazy fashion based on some configuration
            // eventually we should have some kind of curciut breaker that prevents us from going OOM here
            // with some configuration
            this.lookupFactory = completionLookupProvider.load(input);
        } else {
            this.lookupFactory = null;
        }
        this.delegateProducer = delegateProducer;
        success = true;
    } finally {
        if (!success) {
            IOUtils.closeWhileHandlingException(delegateProducer, input);
        } else {
            IOUtils.close(input);
        }
    }
}
 

@Override
public IndexInput openInput(String name, IOContext context) throws IOException {
  ensureOpen();
  if (context.context != Context.MERGE || context.mergeInfo.estimatedMergeBytes < minBytesDirect || fileLength(name) < minBytesDirect) {
    return delegate.openInput(name, context);
  } else {
    return new NativeUnixIndexInput(new File(getDirectory(), name), mergeBufferSize);
  }
}
 

@Override
public IndexOutput createOutput(String name, IOContext context) throws IOException {
  ensureOpen();
  if (context.context != Context.MERGE || context.mergeInfo.estimatedMergeBytes < minBytesDirect) {
    return delegate.createOutput(name, context);
  } else {
    ensureCanWrite(name);
    return new NativeUnixIndexOutput(new File(getDirectory(), name), mergeBufferSize);
  }
}