CacheConfig (Apache HBase 2.0.6 API)

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

Direct Known Subclasses:

MobCacheConfig
```
@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_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_DATA_ON_READ_KEY` Configuration key to cache data blocks on read.
`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`	`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 int`	`DEFAULT_BUCKET_CACHE_WRITER_QUEUE`
`static int`	`DEFAULT_BUCKET_CACHE_WRITER_THREADS` Defaults for Bucket cache
`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`
`static CacheConfig`	`DISABLED` Disabled cache configuration
`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 BlockCache`	`L2_CACHE_INSTANCE`
`private static org.slf4j.Logger`	`LOG`
`private static LruBlockCache`	`ONHEAP_CACHE_INSTANCE`
`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
Modifier	Constructor and Description
`private`	`CacheConfig()`
`(package private)`	`CacheConfig(BlockCache blockCache, boolean cacheDataOnRead, boolean inMemory, boolean cacheDataOnWrite, boolean cacheIndexesOnWrite, boolean cacheBloomsOnWrite, boolean evictOnClose, boolean cacheDataCompressed, boolean prefetchOnOpen, 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, ColumnFamilyDescriptor family)` Create a cache configuration using the specified configuration object and family descriptor.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`(package private) static void`	`clearGlobalInstances()`
`BlockCache`	`getBlockCache()` Returns the block cache.
`(package private) static BucketCache`	`getBucketCache(org.apache.hadoop.conf.Configuration c)`
`private static BlockCache`	`getExternalBlockcache(org.apache.hadoop.conf.Configuration c)`
`CacheStats`	`getL2CacheStats()`
`static LruBlockCache`	`getOnHeapCache(org.apache.hadoop.conf.Configuration c)`
`private static LruBlockCache`	`getOnHeapCacheInternal(org.apache.hadoop.conf.Configuration c)`
`CacheStats`	`getOnHeapCacheStats()`
`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`	`isInMemory()`
`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.slf4j.Logger LOG
```
  - DISABLED
```
public static final CacheConfig DISABLED
```
    Disabled cache configuration
  - CACHE_DATA_ON_READ_KEY
```
public static final String CACHE_DATA_ON_READ_KEY
```
    Configuration key to cache data blocks on read. Bloom blocks and index blocks are always be cached if the block cache is enabled.
    
    See Also:
    
    Constant Field Values
  - 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. This file is NOT the data file. It is a file into which we will serialize the map of what is in the data file. For example, if you pass the following argument as BUCKET_CACHE_IOENGINE_KEY ("hbase.bucketcache.ioengine"), file:/tmp/bucketcache.data , then we will write the bucketcache data to the file /tmp/bucketcache.data but the metadata on where the data is in the supplied file is an in-memory map that needs to be persisted across restarts. Where to store this in-memory state is what you supply here: e.g. /tmp/bucketcache.map.
    
    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_WRITER_THREADS
```
public static final int DEFAULT_BUCKET_CACHE_WRITER_THREADS
```
    Defaults for Bucket cache
    
    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
  - 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.
  - ONHEAP_CACHE_INSTANCE
```
private static LruBlockCache ONHEAP_CACHE_INSTANCE
```
  - L2_CACHE_INSTANCE
```
private static BlockCache L2_CACHE_INSTANCE
```
  - blockCacheDisabled
```
static boolean blockCacheDisabled
```
    Boolean whether we have disabled the block cache entirely.
- Constructor Detail
  - CacheConfig
```
public CacheConfig(org.apache.hadoop.conf.Configuration conf,
                   ColumnFamilyDescriptor 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, ColumnFamilyDescriptor)
    
    Parameters:
    
    conf - hbase configuration
    
    See Also:
    
    CacheConfig(Configuration, ColumnFamilyDescriptor)
  - CacheConfig
```
CacheConfig(BlockCache blockCache,
            boolean cacheDataOnRead,
            boolean inMemory,
            boolean cacheDataOnWrite,
            boolean cacheIndexesOnWrite,
            boolean cacheBloomsOnWrite,
            boolean evictOnClose,
            boolean cacheDataCompressed,
            boolean prefetchOnOpen,
            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
    
    dropBehindCompaction - indicate that we should set drop behind to true when open a store file reader for compaction
  - CacheConfig
```
public CacheConfig(CacheConfig cacheConf)
```
    Constructs a cache configuration copied from the specified configuration.
    
    Parameters:
    
    cacheConf -
  - CacheConfig
```
private CacheConfig()
```
- 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
  - 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
  - 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
  - getOnHeapCache
```
public static LruBlockCache getOnHeapCache(org.apache.hadoop.conf.Configuration c)
```
    Parameters:
    
    c - Configuration to use.
    
    Returns:
    
    An L1 instance. Currently an instance of LruBlockCache.
  - getOnHeapCacheStats
```
public CacheStats getOnHeapCacheStats()
```
  - getL2CacheStats
```
public CacheStats getL2CacheStats()
```
  - getOnHeapCacheInternal
```
private static LruBlockCache getOnHeapCacheInternal(org.apache.hadoop.conf.Configuration c)
```
    Parameters:
    
    c - Configuration to use.
    
    Returns:
    
    An L1 instance. Currently an instance of LruBlockCache.
  - getExternalBlockcache
```
private static BlockCache getExternalBlockcache(org.apache.hadoop.conf.Configuration c)
```
  - getBucketCache
```
static BucketCache 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.
  - clearGlobalInstances
```
static void clearGlobalInstances()
```

Class CacheConfig

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

DISABLED

CACHE_DATA_ON_READ_KEY

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_WRITER_THREADS_KEY

BUCKET_CACHE_WRITER_QUEUE_KEY

BUCKET_CACHE_BUCKETS_KEY

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

dropBehindCompaction

GLOBAL_BLOCK_CACHE_INSTANCE

ONHEAP_CACHE_INSTANCE

L2_CACHE_INSTANCE

blockCacheDisabled

Constructor Detail

CacheConfig

CacheConfig

CacheConfig

CacheConfig

CacheConfig

Method Detail

isBlockCacheEnabled

getBlockCache

shouldCacheDataOnRead

shouldDropBehindCompaction

shouldCacheBlockOnRead

isInMemory

shouldCacheDataOnWrite

setCacheDataOnWrite

shouldCacheIndexesOnWrite

shouldCacheBloomsOnWrite

shouldEvictOnClose

setEvictOnClose

shouldCacheDataCompressed

shouldCacheCompressed

shouldPrefetchOnOpen

shouldReadBlockFromCache

shouldLockOnCacheMiss

toString

getOnHeapCache

getOnHeapCacheStats

getL2CacheStats

getOnHeapCacheInternal

getExternalBlockcache