CacheConfig (Apache HBase 1.2.12 API)

java.lang.Object
- org.apache.hadoop.hbase.io.hfile.CacheConfig

@InterfaceAudience.Private
public class CacheConfig
extends Object

Stores all of the cache objects and configuration for a single HFile.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

private static class CacheConfig.ExternalBlockCaches
Enum of all built in external block caches.

Nested Classes
Modifier and Type	Class and Description
`private static class`	`CacheConfig.ExternalBlockCaches` Enum of all built in external block caches.

Field Summary

Fields
Modifier and Type	Field and Description
`private BlockCache`	`blockCache` Local reference to the block cache, null if completely disabled
`static String`	`BLOCKCACHE_BLOCKSIZE_KEY` The target block size used by blockcache instances.
`(package private) static boolean`	`blockCacheDisabled` Boolean whether we have disabled the block cache entirely.
`static String`	`BUCKET_CACHE_BUCKETS_KEY` A comma-delimited array of values for use as bucket sizes.
`static String`	`BUCKET_CACHE_COMBINED_KEY` If the bucket cache is used in league with the lru on-heap block cache (meta blocks such as indices and blooms are kept in the lru blockcache and the data blocks in the bucket cache).
`static String`	`BUCKET_CACHE_PERSISTENT_PATH_KEY` If the chosen ioengine can persist its state across restarts, the path to the file to persist to.
`static String`	`BUCKET_CACHE_WRITER_QUEUE_KEY`
`static String`	`BUCKET_CACHE_WRITER_THREADS_KEY`
`static String`	`CACHE_BLOCKS_ON_WRITE_KEY` Configuration key to cache data blocks on write.
`static String`	`CACHE_BLOOM_BLOCKS_ON_WRITE_KEY` Configuration key to cache compound bloom filter blocks on write.
`static String`	`CACHE_DATA_BLOCKS_COMPRESSED_KEY` Configuration key to cache data blocks in compressed and/or encrypted format.
`static String`	`CACHE_INDEX_BLOCKS_ON_WRITE_KEY` Configuration key to cache leaf and intermediate-level index blocks on write.
`private boolean`	`cacheBloomsOnWrite` Whether compound bloom filter blocks should be cached on write
`private boolean`	`cacheDataCompressed` Whether data blocks should be stored in compressed and/or encrypted form in the cache
`private boolean`	`cacheDataInL1` If true and if more than one tier in this cache deploy -- e.g.
`private boolean`	`cacheDataOnRead` Whether blocks should be cached on read (default is on if there is a cache but this can be turned off on a per-family or per-request basis).
`private boolean`	`cacheDataOnWrite` Whether data blocks should be cached when new files are written
`private boolean`	`cacheIndexesOnWrite` Whether index blocks should be cached when new files are written
`static boolean`	`DEFAULT_BUCKET_CACHE_COMBINED` Defaults for Bucket cache
`static int`	`DEFAULT_BUCKET_CACHE_WRITER_QUEUE`
`static int`	`DEFAULT_BUCKET_CACHE_WRITER_THREADS`
`static boolean`	`DEFAULT_CACHE_BLOOMS_ON_WRITE`
`static boolean`	`DEFAULT_CACHE_DATA_COMPRESSED`
`static boolean`	`DEFAULT_CACHE_DATA_ON_READ`
`static boolean`	`DEFAULT_CACHE_DATA_ON_WRITE`
`static boolean`	`DEFAULT_CACHE_INDEXES_ON_WRITE`
`static boolean`	`DEFAULT_EVICT_ON_CLOSE`
`static boolean`	`DEFAULT_IN_MEMORY`
`static boolean`	`DEFAULT_PREFETCH_ON_OPEN`
`private static boolean`	`DROP_BEHIND_CACHE_COMPACTION_DEFAULT`
`private static String`	`DROP_BEHIND_CACHE_COMPACTION_KEY`
`private boolean`	`dropBehindCompaction`
`static String`	`EVICT_BLOCKS_ON_CLOSE_KEY` Configuration key to evict all blocks of a given file from the block cache when the file is closed.
`private boolean`	`evictOnClose` Whether blocks of a file should be evicted when the file is closed
`private static String`	`EXTERNAL_BLOCKCACHE_CLASS_KEY`
`private static boolean`	`EXTERNAL_BLOCKCACHE_DEFAULT`
`private static String`	`EXTERNAL_BLOCKCACHE_KEY`
`(package private) static BlockCache`	`GLOBAL_BLOCK_CACHE_INSTANCE` Static reference to the block cache, or null if no caching should be used at all.
`private boolean`	`inMemory` Whether blocks should be flagged as in-memory when being cached
`private static org.apache.commons.logging.Log`	`LOG`
`static String`	`PREFETCH_BLOCKS_ON_OPEN_KEY` Configuration key to prefetch all blocks of a given file into the block cache when the file is opened.
`private boolean`	`prefetchOnOpen` Whether data blocks should be prefetched into the cache

Constructor Summary

Constructors
Constructor and Description
`CacheConfig(BlockCache blockCache, boolean cacheDataOnRead, boolean inMemory, boolean cacheDataOnWrite, boolean cacheIndexesOnWrite, boolean cacheBloomsOnWrite, boolean evictOnClose, boolean cacheDataCompressed, boolean prefetchOnOpen, boolean cacheDataInL1, boolean dropBehindCompaction)` Create a block cache configuration with the specified cache and configuration parameters.
`CacheConfig(CacheConfig cacheConf)` Constructs a cache configuration copied from the specified configuration.
`CacheConfig(org.apache.hadoop.conf.Configuration conf)` Create a cache configuration using the specified configuration object and defaults for family level settings.
`CacheConfig(org.apache.hadoop.conf.Configuration conf, HColumnDescriptor family)` Create a cache configuration using the specified configuration object and family descriptor.

Method Summary

Methods
Modifier and Type	Method and Description
`BlockCache`	`getBlockCache()` Returns the block cache.
`private static BlockCache`	`getBucketCache(org.apache.hadoop.conf.Configuration c)`
`private static BlockCache`	`getExternalBlockcache(org.apache.hadoop.conf.Configuration c)`
`private static LruBlockCache`	`getL1(org.apache.hadoop.conf.Configuration c)`
`private static BlockCache`	`getL2(org.apache.hadoop.conf.Configuration c)`
`static BlockCache`	`instantiateBlockCache(org.apache.hadoop.conf.Configuration conf)` Returns the block cache or `null` in case none should be used.
`boolean`	`isBlockCacheEnabled()` Checks whether the block cache is enabled.
`boolean`	`isCacheDataInL1()`
`boolean`	`isInMemory()`
`void`	`setCacheDataInL1(boolean cacheDataInL1)` Only used for testing.
`void`	`setCacheDataOnWrite(boolean cacheDataOnWrite)` Only used for testing.
`void`	`setEvictOnClose(boolean evictOnClose)` Only used for testing.
`boolean`	`shouldCacheBlockOnRead(BlockType.BlockCategory category)` Should we cache a block of a particular category? We always cache important blocks such as index blocks, as long as the block cache is available.
`boolean`	`shouldCacheBloomsOnWrite()`
`boolean`	`shouldCacheCompressed(BlockType.BlockCategory category)`
`boolean`	`shouldCacheDataCompressed()`
`boolean`	`shouldCacheDataOnRead()` Returns whether the DATA blocks of this HFile should be cached on read or not (we always cache the meta blocks, the INDEX and BLOOM blocks).
`boolean`	`shouldCacheDataOnWrite()`
`boolean`	`shouldCacheIndexesOnWrite()`
`boolean`	`shouldDropBehindCompaction()`
`boolean`	`shouldEvictOnClose()`
`boolean`	`shouldLockOnCacheMiss(BlockType blockType)` If we make sure the block could not be cached, we will not acquire the lock otherwise we will acquire lock
`boolean`	`shouldPrefetchOnOpen()`
`boolean`	`shouldReadBlockFromCache(BlockType blockType)` Return true if we may find this type of block in block cache.
`String`	`toString()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - LOG
```
private static final org.apache.commons.logging.Log LOG
```
  - CACHE_BLOCKS_ON_WRITE_KEY
```
public static final String CACHE_BLOCKS_ON_WRITE_KEY
```
    Configuration key to cache data blocks on write. There are separate switches for bloom blocks and non-root index blocks.
    
    See Also:
    Constant Field Values
  - CACHE_INDEX_BLOCKS_ON_WRITE_KEY
```
public static final String CACHE_INDEX_BLOCKS_ON_WRITE_KEY
```
    Configuration key to cache leaf and intermediate-level index blocks on write.
    
    See Also:
    Constant Field Values
  - CACHE_BLOOM_BLOCKS_ON_WRITE_KEY
```
public static final String CACHE_BLOOM_BLOCKS_ON_WRITE_KEY
```
    Configuration key to cache compound bloom filter blocks on write.
    
    See Also:
    Constant Field Values
  - CACHE_DATA_BLOCKS_COMPRESSED_KEY
```
public static final String CACHE_DATA_BLOCKS_COMPRESSED_KEY
```
    Configuration key to cache data blocks in compressed and/or encrypted format.
    
    See Also:
    Constant Field Values
  - EVICT_BLOCKS_ON_CLOSE_KEY
```
public static final String EVICT_BLOCKS_ON_CLOSE_KEY
```
    Configuration key to evict all blocks of a given file from the block cache when the file is closed.
    
    See Also:
    Constant Field Values
  - BUCKET_CACHE_PERSISTENT_PATH_KEY
```
public static final String BUCKET_CACHE_PERSISTENT_PATH_KEY
```
    If the chosen ioengine can persist its state across restarts, the path to the file to persist to.
    
    See Also:
    Constant Field Values
  - BUCKET_CACHE_COMBINED_KEY
```
public static final String BUCKET_CACHE_COMBINED_KEY
```
    If the bucket cache is used in league with the lru on-heap block cache (meta blocks such as indices and blooms are kept in the lru blockcache and the data blocks in the bucket cache).
    
    See Also:
    Constant Field Values
  - BUCKET_CACHE_WRITER_THREADS_KEY
```
public static final String BUCKET_CACHE_WRITER_THREADS_KEY
```
    See Also:
    Constant Field Values
  - BUCKET_CACHE_WRITER_QUEUE_KEY
```
public static final String BUCKET_CACHE_WRITER_QUEUE_KEY
```
    See Also:
    Constant Field Values
  - BUCKET_CACHE_BUCKETS_KEY
```
public static final String BUCKET_CACHE_BUCKETS_KEY
```
    A comma-delimited array of values for use as bucket sizes.
    
    See Also:
    Constant Field Values
  - DEFAULT_BUCKET_CACHE_COMBINED
```
public static final boolean DEFAULT_BUCKET_CACHE_COMBINED
```
    Defaults for Bucket cache
    
    See Also:
    Constant Field Values
  - DEFAULT_BUCKET_CACHE_WRITER_THREADS
```
public static final int DEFAULT_BUCKET_CACHE_WRITER_THREADS
```
    See Also:
    Constant Field Values
  - DEFAULT_BUCKET_CACHE_WRITER_QUEUE
```
public static final int DEFAULT_BUCKET_CACHE_WRITER_QUEUE
```
    See Also:
    Constant Field Values
  - PREFETCH_BLOCKS_ON_OPEN_KEY
```
public static final String PREFETCH_BLOCKS_ON_OPEN_KEY
```
    Configuration key to prefetch all blocks of a given file into the block cache when the file is opened.
    
    See Also:
    Constant Field Values
  - BLOCKCACHE_BLOCKSIZE_KEY
```
public static final String BLOCKCACHE_BLOCKSIZE_KEY
```
    The target block size used by blockcache instances. Defaults to HConstants.DEFAULT_BLOCKSIZE. TODO: this config point is completely wrong, as it's used to determine the target block size of BlockCache instances. Rename.
    
    See Also:
    Constant Field Values
  - EXTERNAL_BLOCKCACHE_KEY
```
private static final String EXTERNAL_BLOCKCACHE_KEY
```
    See Also:
    Constant Field Values
  - EXTERNAL_BLOCKCACHE_DEFAULT
```
private static final boolean EXTERNAL_BLOCKCACHE_DEFAULT
```
    See Also:
    Constant Field Values
  - EXTERNAL_BLOCKCACHE_CLASS_KEY
```
private static final String EXTERNAL_BLOCKCACHE_CLASS_KEY
```
    See Also:
    Constant Field Values
  - DROP_BEHIND_CACHE_COMPACTION_KEY
```
private static final String DROP_BEHIND_CACHE_COMPACTION_KEY
```
    See Also:
    Constant Field Values
  - DROP_BEHIND_CACHE_COMPACTION_DEFAULT
```
private static final boolean DROP_BEHIND_CACHE_COMPACTION_DEFAULT
```
    See Also:
    Constant Field Values
  - DEFAULT_CACHE_DATA_ON_READ
```
public static final boolean DEFAULT_CACHE_DATA_ON_READ
```
    See Also:
    Constant Field Values
  - DEFAULT_CACHE_DATA_ON_WRITE
```
public static final boolean DEFAULT_CACHE_DATA_ON_WRITE
```
    See Also:
    Constant Field Values
  - DEFAULT_IN_MEMORY
```
public static final boolean DEFAULT_IN_MEMORY
```
    See Also:
    Constant Field Values
  - DEFAULT_CACHE_INDEXES_ON_WRITE
```
public static final boolean DEFAULT_CACHE_INDEXES_ON_WRITE
```
    See Also:
    Constant Field Values
  - DEFAULT_CACHE_BLOOMS_ON_WRITE
```
public static final boolean DEFAULT_CACHE_BLOOMS_ON_WRITE
```
    See Also:
    Constant Field Values
  - DEFAULT_EVICT_ON_CLOSE
```
public static final boolean DEFAULT_EVICT_ON_CLOSE
```
    See Also:
    Constant Field Values
  - DEFAULT_CACHE_DATA_COMPRESSED
```
public static final boolean DEFAULT_CACHE_DATA_COMPRESSED
```
    See Also:
    Constant Field Values
  - DEFAULT_PREFETCH_ON_OPEN
```
public static final boolean DEFAULT_PREFETCH_ON_OPEN
```
    See Also:
    Constant Field Values
  - blockCache
```
private final BlockCache blockCache
```
    Local reference to the block cache, null if completely disabled
  - cacheDataOnRead
```
private boolean cacheDataOnRead
```
    Whether blocks should be cached on read (default is on if there is a cache but this can be turned off on a per-family or per-request basis). If off we will STILL cache meta blocks; i.e. INDEX and BLOOM types. This cannot be disabled.
  - inMemory
```
private final boolean inMemory
```
    Whether blocks should be flagged as in-memory when being cached
  - cacheDataOnWrite
```
private boolean cacheDataOnWrite
```
    Whether data blocks should be cached when new files are written
  - cacheIndexesOnWrite
```
private final boolean cacheIndexesOnWrite
```
    Whether index blocks should be cached when new files are written
  - cacheBloomsOnWrite
```
private final boolean cacheBloomsOnWrite
```
    Whether compound bloom filter blocks should be cached on write
  - evictOnClose
```
private boolean evictOnClose
```
    Whether blocks of a file should be evicted when the file is closed
  - cacheDataCompressed
```
private final boolean cacheDataCompressed
```
    Whether data blocks should be stored in compressed and/or encrypted form in the cache
  - prefetchOnOpen
```
private final boolean prefetchOnOpen
```
    Whether data blocks should be prefetched into the cache
  - cacheDataInL1
```
private boolean cacheDataInL1
```
    If true and if more than one tier in this cache deploy -- e.g. CombinedBlockCache has an L1 and an L2 tier -- then cache data blocks up in the L1 tier (The meta blocks are likely being cached up in L1 already. At least this is the case if CombinedBlockCache).
  - dropBehindCompaction
```
private final boolean dropBehindCompaction
```
  - GLOBAL_BLOCK_CACHE_INSTANCE
```
static BlockCache GLOBAL_BLOCK_CACHE_INSTANCE
```
    Static reference to the block cache, or null if no caching should be used at all.
  - blockCacheDisabled
```
static boolean blockCacheDisabled
```
    Boolean whether we have disabled the block cache entirely.
- Constructor Detail
  - CacheConfig
```
public CacheConfig(org.apache.hadoop.conf.Configuration conf,
           HColumnDescriptor family)
```
    Create a cache configuration using the specified configuration object and family descriptor.
    
    Parameters:
    conf - hbase configuration
    family - column family configuration
  - CacheConfig
```
public CacheConfig(org.apache.hadoop.conf.Configuration conf)
```
    Create a cache configuration using the specified configuration object and defaults for family level settings. Only use if no column family context. Prefer CacheConfig(Configuration, HColumnDescriptor)
    
    Parameters:
    conf - hbase configuration
    See Also:
    CacheConfig(Configuration, HColumnDescriptor)
  - CacheConfig
```
CacheConfig(BlockCache blockCache,
           boolean cacheDataOnRead,
           boolean inMemory,
           boolean cacheDataOnWrite,
           boolean cacheIndexesOnWrite,
           boolean cacheBloomsOnWrite,
           boolean evictOnClose,
           boolean cacheDataCompressed,
           boolean prefetchOnOpen,
           boolean cacheDataInL1,
           boolean dropBehindCompaction)
```
    Create a block cache configuration with the specified cache and configuration parameters.
    
    Parameters:
    blockCache - reference to block cache, null if completely disabled
    cacheDataOnRead - whether DATA blocks should be cached on read (we always cache INDEX blocks and BLOOM blocks; this cannot be disabled).
    inMemory - whether blocks should be flagged as in-memory
    cacheDataOnWrite - whether data blocks should be cached on write
    cacheIndexesOnWrite - whether index blocks should be cached on write
    cacheBloomsOnWrite - whether blooms should be cached on write
    evictOnClose - whether blocks should be evicted when HFile is closed
    cacheDataCompressed - whether to store blocks as compressed in the cache
    prefetchOnOpen - whether to prefetch blocks upon open
    cacheDataInL1 - If more than one cache tier deployed, if true, cache this column families data blocks up in the L1 tier.
  - CacheConfig
```
public CacheConfig(CacheConfig cacheConf)
```
    Constructs a cache configuration copied from the specified configuration.
    
    Parameters:
    cacheConf -
- Method Detail
  - isBlockCacheEnabled
```
public boolean isBlockCacheEnabled()
```
    Checks whether the block cache is enabled.
  - getBlockCache
```
public BlockCache getBlockCache()
```
    Returns the block cache.
    
    Returns:
    the block cache, or null if caching is completely disabled
  - shouldCacheDataOnRead
```
public boolean shouldCacheDataOnRead()
```
    Returns whether the DATA blocks of this HFile should be cached on read or not (we always cache the meta blocks, the INDEX and BLOOM blocks).
    
    Returns:
    true if blocks should be cached on read, false if not
  - shouldDropBehindCompaction
```
public boolean shouldDropBehindCompaction()
```
  - shouldCacheBlockOnRead
```
public boolean shouldCacheBlockOnRead(BlockType.BlockCategory category)
```
    Should we cache a block of a particular category? We always cache important blocks such as index blocks, as long as the block cache is available.
  - isInMemory
```
public boolean isInMemory()
```
    Returns:
    true if blocks in this file should be flagged as in-memory
  - isCacheDataInL1
```
public boolean isCacheDataInL1()
```
    Returns:
    True if cache data blocks in L1 tier (if more than one tier in block cache deploy).
  - shouldCacheDataOnWrite
```
public boolean shouldCacheDataOnWrite()
```
    Returns:
    true if data blocks should be written to the cache when an HFile is written, false if not
  - setCacheDataOnWrite
```
public void setCacheDataOnWrite(boolean cacheDataOnWrite)
```
    Only used for testing.
    
    Parameters:
    cacheDataOnWrite - whether data blocks should be written to the cache when an HFile is written
  - setCacheDataInL1
```
public void setCacheDataInL1(boolean cacheDataInL1)
```
    Only used for testing.
    
    Parameters:
    cacheDataInL1 - Whether to cache data blocks up in l1 (if a multi-tier cache implementation).
  - shouldCacheIndexesOnWrite
```
public boolean shouldCacheIndexesOnWrite()
```
    Returns:
    true if index blocks should be written to the cache when an HFile is written, false if not
  - shouldCacheBloomsOnWrite
```
public boolean shouldCacheBloomsOnWrite()
```
    Returns:
    true if bloom blocks should be written to the cache when an HFile is written, false if not
  - shouldEvictOnClose
```
public boolean shouldEvictOnClose()
```
    Returns:
    true if blocks should be evicted from the cache when an HFile reader is closed, false if not
  - setEvictOnClose
```
public void setEvictOnClose(boolean evictOnClose)
```
    Only used for testing.
    
    Parameters:
    evictOnClose - whether blocks should be evicted from the cache when an HFile reader is closed
  - shouldCacheDataCompressed
```
public boolean shouldCacheDataCompressed()
```
    Returns:
    true if data blocks should be compressed in the cache, false if not
  - shouldCacheCompressed
```
public boolean shouldCacheCompressed(BlockType.BlockCategory category)
```
    Returns:
    true if this BlockType.BlockCategory should be compressed in blockcache, false otherwise
  - shouldPrefetchOnOpen
```
public boolean shouldPrefetchOnOpen()
```
    Returns:
    true if blocks should be prefetched into the cache on open, false if not
  - shouldReadBlockFromCache
```
public boolean shouldReadBlockFromCache(BlockType blockType)
```
    Return true if we may find this type of block in block cache.
    TODO: today family.isBlockCacheEnabled() only means cacheDataOnRead, so here we consider lots of other configurations such as cacheDataOnWrite. We should fix this in the future, cacheDataOnWrite should honor the CF level isBlockCacheEnabled configuration.
  - shouldLockOnCacheMiss
```
public boolean shouldLockOnCacheMiss(BlockType blockType)
```
    If we make sure the block could not be cached, we will not acquire the lock otherwise we will acquire lock
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getL1
```
private static LruBlockCache getL1(org.apache.hadoop.conf.Configuration c)
```
    Parameters:
    c - Configuration to use.
    
    Returns:
    An L1 instance. Currently an instance of LruBlockCache.
  - getL2
```
private static BlockCache getL2(org.apache.hadoop.conf.Configuration c)
```
    Parameters:
    c - Configuration to use.
    
    Returns:
    Returns L2 block cache instance (for now it is BucketCache BlockCache all the time) or null if not supposed to be a L2.
  - getExternalBlockcache
```
private static BlockCache getExternalBlockcache(org.apache.hadoop.conf.Configuration c)
```
  - getBucketCache
```
private static BlockCache getBucketCache(org.apache.hadoop.conf.Configuration c)
```
  - instantiateBlockCache
```
public static BlockCache instantiateBlockCache(org.apache.hadoop.conf.Configuration conf)
```
    Returns the block cache or null in case none should be used. Sets GLOBAL_BLOCK_CACHE_INSTANCE
    
    Parameters:
    conf - The current configuration.
    
    Returns:
    The block cache or null.

Class CacheConfig

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

CACHE_BLOCKS_ON_WRITE_KEY

CACHE_INDEX_BLOCKS_ON_WRITE_KEY

CACHE_BLOOM_BLOCKS_ON_WRITE_KEY

CACHE_DATA_BLOCKS_COMPRESSED_KEY

EVICT_BLOCKS_ON_CLOSE_KEY

BUCKET_CACHE_PERSISTENT_PATH_KEY

BUCKET_CACHE_COMBINED_KEY

BUCKET_CACHE_WRITER_THREADS_KEY

BUCKET_CACHE_WRITER_QUEUE_KEY

BUCKET_CACHE_BUCKETS_KEY

DEFAULT_BUCKET_CACHE_COMBINED

DEFAULT_BUCKET_CACHE_WRITER_THREADS

DEFAULT_BUCKET_CACHE_WRITER_QUEUE

PREFETCH_BLOCKS_ON_OPEN_KEY

BLOCKCACHE_BLOCKSIZE_KEY

EXTERNAL_BLOCKCACHE_KEY

EXTERNAL_BLOCKCACHE_DEFAULT

EXTERNAL_BLOCKCACHE_CLASS_KEY

DROP_BEHIND_CACHE_COMPACTION_KEY

DROP_BEHIND_CACHE_COMPACTION_DEFAULT

DEFAULT_CACHE_DATA_ON_READ

DEFAULT_CACHE_DATA_ON_WRITE

DEFAULT_IN_MEMORY

DEFAULT_CACHE_INDEXES_ON_WRITE

DEFAULT_CACHE_BLOOMS_ON_WRITE

DEFAULT_EVICT_ON_CLOSE

DEFAULT_CACHE_DATA_COMPRESSED

DEFAULT_PREFETCH_ON_OPEN

blockCache

cacheDataOnRead

inMemory

cacheDataOnWrite

cacheIndexesOnWrite

cacheBloomsOnWrite

evictOnClose

cacheDataCompressed

prefetchOnOpen

cacheDataInL1

dropBehindCompaction

GLOBAL_BLOCK_CACHE_INSTANCE

blockCacheDisabled

Constructor Detail

CacheConfig

CacheConfig

CacheConfig

CacheConfig

Method Detail

isBlockCacheEnabled

getBlockCache

shouldCacheDataOnRead

shouldDropBehindCompaction

shouldCacheBlockOnRead

isInMemory

isCacheDataInL1

shouldCacheDataOnWrite

setCacheDataOnWrite

setCacheDataInL1

shouldCacheIndexesOnWrite

shouldCacheBloomsOnWrite

shouldEvictOnClose

setEvictOnClose

shouldCacheDataCompressed

shouldCacheCompressed

shouldPrefetchOnOpen

shouldReadBlockFromCache

shouldLockOnCacheMiss

toString

getL1

getL2

getExternalBlockcache

getBucketCache

instantiateBlockCache