Java BitsetFilterCache类代码示例

import org.elasticsearch.index.cache.bitset.BitsetFilterCache; //导入依赖的package包/类
@Inject
public IndexQueryParserService(Index index, IndexSettingsService indexSettingsService,
                               IndicesQueriesRegistry indicesQueriesRegistry,
                               ScriptService scriptService, AnalysisService analysisService,
                               MapperService mapperService, IndexCache indexCache, IndexFieldDataService fieldDataService,
                               BitsetFilterCache bitsetFilterCache,
                               @Nullable SimilarityService similarityService) {
    super(index, indexSettingsService.getSettings());
    this.indexSettingsService = indexSettingsService;
    this.scriptService = scriptService;
    this.analysisService = analysisService;
    this.mapperService = mapperService;
    this.similarityService = similarityService;
    this.indexCache = indexCache;
    this.fieldDataService = fieldDataService;
    this.bitsetFilterCache = bitsetFilterCache;

    Settings indexSettings = indexSettingsService.getSettings();
    this.defaultField = indexSettings.get(DEFAULT_FIELD, AllFieldMapper.NAME);
    this.queryStringLenient = indexSettings.getAsBoolean(QUERY_STRING_LENIENT, false);
    this.parseFieldMatcher = new ParseFieldMatcher(indexSettings);
    this.defaultAllowUnmappedFields = indexSettings.getAsBoolean(ALLOW_UNMAPPED, true);
    this.indicesQueriesRegistry = indicesQueriesRegistry;
}
 

import org.elasticsearch.index.cache.bitset.BitsetFilterCache; //导入依赖的package包/类
public QueryShardContext(int shardId, IndexSettings indexSettings, BitsetFilterCache bitsetFilterCache,
        IndexFieldDataService indexFieldDataService, MapperService mapperService, SimilarityService similarityService,
        ScriptService scriptService, NamedXContentRegistry xContentRegistry,
        Client client, IndexReader reader, LongSupplier nowInMillis) {
    super(indexSettings, mapperService, scriptService, xContentRegistry, client, reader, nowInMillis);
    this.shardId = shardId;
    this.indexSettings = indexSettings;
    this.similarityService = similarityService;
    this.mapperService = mapperService;
    this.bitsetFilterCache = bitsetFilterCache;
    this.indexFieldDataService = indexFieldDataService;
    this.allowUnmappedFields = indexSettings.isDefaultAllowUnmappedFields();
    this.nestedScope = new NestedScope();

}
 

import org.elasticsearch.index.cache.bitset.BitsetFilterCache; //导入依赖的package包/类
@Inject
public IndexService(Injector injector, Index index, NodeEnvironment nodeEnv,
                    AnalysisService analysisService, MapperService mapperService, IndexQueryParserService queryParserService,
                    SimilarityService similarityService, IndexAliasesService aliasesService, IndexCache indexCache,
                    IndexSettingsService settingsService,
                    IndexFieldDataService indexFieldData, BitsetFilterCache bitSetFilterCache, IndicesService indicesServices) {

    super(index, settingsService.getSettings());
    this.injector = injector;
    this.analysisService = analysisService;
    this.mapperService = mapperService;
    this.queryParserService = queryParserService;
    this.similarityService = similarityService;
    this.aliasesService = aliasesService;
    this.indexCache = indexCache;
    this.indexFieldData = indexFieldData;
    this.settingsService = settingsService;
    this.bitsetFilterCache = bitSetFilterCache;

    this.pluginsService = injector.getInstance(PluginsService.class);
    this.indicesServices = indicesServices;
    this.indicesLifecycle = (InternalIndicesLifecycle) injector.getInstance(IndicesLifecycle.class);

    // inject workarounds for cyclic dep
    indexFieldData.setListener(new FieldDataCacheListener(this));
    bitSetFilterCache.setListener(new BitsetCacheListener(this));
    this.nodeEnv = nodeEnv;
}
 

import org.elasticsearch.index.cache.bitset.BitsetFilterCache; //导入依赖的package包/类
@Override
public BitsetFilterCache bitsetFilterCache() {
    return fixedBitSetFilterCache;
}
 

import org.elasticsearch.index.cache.bitset.BitsetFilterCache; //导入依赖的package包/类
@Override
public BitsetFilterCache bitsetFilterCache() {
    return in.bitsetFilterCache();
}
 

import org.elasticsearch.index.cache.bitset.BitsetFilterCache; //导入依赖的package包/类
@Override
public BitsetFilterCache bitsetFilterCache() {
    return indexService.cache().bitsetFilterCache();
}
 

import org.elasticsearch.index.cache.bitset.BitsetFilterCache; //导入依赖的package包/类
public IndexService(IndexSettings indexSettings, NodeEnvironment nodeEnv,
                    NamedXContentRegistry xContentRegistry,
                    SimilarityService similarityService,
                    ShardStoreDeleter shardStoreDeleter,
                    AnalysisRegistry registry,
                    @Nullable EngineFactory engineFactory,
                    CircuitBreakerService circuitBreakerService,
                    BigArrays bigArrays,
                    ThreadPool threadPool,
                    ScriptService scriptService,
                    ClusterService clusterService,
                    Client client,
                    QueryCache queryCache,
                    IndexStore indexStore,
                    IndexEventListener eventListener,
                    IndexModule.IndexSearcherWrapperFactory wrapperFactory,
                    MapperRegistry mapperRegistry,
                    IndicesFieldDataCache indicesFieldDataCache,
                    Consumer<ShardId> globalCheckpointSyncer,
                    List<SearchOperationListener> searchOperationListeners,
                    List<IndexingOperationListener> indexingOperationListeners) throws IOException {
    super(indexSettings);
    this.indexSettings = indexSettings;
    this.globalCheckpointSyncer = globalCheckpointSyncer;
    this.xContentRegistry = xContentRegistry;
    this.similarityService = similarityService;
    this.mapperService = new MapperService(indexSettings, registry.build(indexSettings), xContentRegistry, similarityService,
        mapperRegistry,
        // we parse all percolator queries as they would be parsed on shard 0
        () -> newQueryShardContext(0, null, () -> {
            throw new IllegalArgumentException("Percolator queries are not allowed to use the current timestamp");
        }));
    this.indexFieldData = new IndexFieldDataService(indexSettings, indicesFieldDataCache, circuitBreakerService, mapperService);
    this.shardStoreDeleter = shardStoreDeleter;
    this.bigArrays = bigArrays;
    this.threadPool = threadPool;
    this.scriptService = scriptService;
    this.clusterService = clusterService;
    this.client = client;
    this.eventListener = eventListener;
    this.nodeEnv = nodeEnv;
    this.indexStore = indexStore;
    indexFieldData.setListener(new FieldDataCacheListener(this));
    this.bitsetFilterCache = new BitsetFilterCache(indexSettings, new BitsetCacheListener(this));
    this.warmer = new IndexWarmer(indexSettings.getSettings(), threadPool,
        bitsetFilterCache.createListener(threadPool));
    this.indexCache = new IndexCache(indexSettings, queryCache, bitsetFilterCache);
    this.engineFactory = engineFactory;
    // initialize this last -- otherwise if the wrapper requires any other member to be non-null we fail with an NPE
    this.searcherWrapper = wrapperFactory.newWrapper(this);
    this.globalCheckpointTask = new AsyncGlobalCheckpointTask(this);
    this.indexingOperationListeners = Collections.unmodifiableList(indexingOperationListeners);
    this.searchOperationListeners = Collections.unmodifiableList(searchOperationListeners);
    // kick off async ops for the first shard in this index
    this.refreshTask = new AsyncRefreshTask(this);
    rescheduleFsyncTask(indexSettings.getTranslogDurability());
}
 

import org.elasticsearch.index.cache.bitset.BitsetFilterCache; //导入依赖的package包/类
public IndexCache(IndexSettings indexSettings, QueryCache queryCache, BitsetFilterCache bitsetFilterCache) {
    super(indexSettings);
    this.queryCache = queryCache;
    this.bitsetFilterCache = bitsetFilterCache;
}
 

import org.elasticsearch.index.cache.bitset.BitsetFilterCache; //导入依赖的package包/类
/**
 * Return the {@link BitsetFilterCache} for this index.
 */
public BitsetFilterCache bitsetFilterCache() {
    return bitsetFilterCache;
}
 

import org.elasticsearch.index.cache.bitset.BitsetFilterCache; //导入依赖的package包/类
protected Nested createNested(IndexSearcher searcher, Query parentFilter, Query childFilter) throws IOException {
    BitsetFilterCache s = indexService.cache().bitsetFilterCache();
    return new Nested(s.getBitSetProducer(parentFilter), childFilter);
}
 

import org.elasticsearch.index.cache.bitset.BitsetFilterCache; //导入依赖的package包/类
@Override
public BitsetFilterCache bitsetFilterCache() {
    return indexService.bitsetFilterCache();
}
 

import org.elasticsearch.index.cache.bitset.BitsetFilterCache; //导入依赖的package包/类
public BitsetFilterCache bitsetFilterCache() {
    return bitsetFilterCache;
}
 

import org.elasticsearch.index.cache.bitset.BitsetFilterCache; //导入依赖的package包/类
@Inject
public IndexCache(Index index, IndexSettingsService indexSettingsService, QueryCache queryCache, BitsetFilterCache bitsetFilterCache) {
    super(index, indexSettingsService.getSettings());
    this.queryCache = queryCache;
    this.bitsetFilterCache = bitsetFilterCache;
}
 

import org.elasticsearch.index.cache.bitset.BitsetFilterCache; //导入依赖的package包/类
@Override
protected void configure() {
    queryCaches.bindType(binder(), indexSettings, QUERY_CACHE_TYPE, INDEX_QUERY_CACHE);
    bind(BitsetFilterCache.class).asEagerSingleton();
    bind(IndexCache.class).asEagerSingleton();
}
 

import org.elasticsearch.index.cache.bitset.BitsetFilterCache; //导入依赖的package包/类
public abstract BitsetFilterCache bitsetFilterCache();