HStore (Apache HBase 1.2.12 API)

java.lang.Object
- org.apache.hadoop.hbase.regionserver.HStore

All Implemented Interfaces:

ConfigurationObserver, PropagatingConfigurationObserver, HeapSize, Store, StoreConfigInformation
```
@InterfaceAudience.Private
public class HStore
extends Object
implements Store
```
A Store holds a column family in a Region. Its a memstore and a set of zero or more StoreFiles, which stretch backwards over time.
There's no reason to consider append-logging at this level; all logging and locking is handled at the HRegion level. Store just provides services to manage sets of StoreFiles. One of the most important of those services is compaction services where files are aggregated once they pass a configurable threshold.
Locking and transactions are handled at a higher level. This API should not be called directly but by an HRegion manager.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

private class HStore.StoreFlusherImpl

Nested Classes
Modifier and Type	Class and Description
`private class`	`HStore.StoreFlusherImpl`

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`BLOCKING_STOREFILES_KEY`
`private long`	`blockingFileCount`
`private int`	`blocksize`
`private int`	`bytesPerChecksum`
`private CacheConfig`	`cacheConf`
`private Set<ChangedReadersObserver>`	`changedReaderObservers`
`private ChecksumType`	`checksumType` Checksum configuration
`(package private) static int`	`closeCheckInterval`
`static String`	`COMPACTCHECKER_INTERVAL_MULTIPLIER_KEY`
`private long`	`compactedCellsCount`
`private long`	`compactedCellsSize`
`private int`	`compactionCheckMultiplier`
`private KeyValue.KVComparator`	`comparator`
`private org.apache.hadoop.conf.Configuration`	`conf`
`private Encryption.Context`	`cryptoContext`
`private HFileDataBlockEncoder`	`dataBlockEncoder`
`static long`	`DEEP_OVERHEAD`
`static int`	`DEFAULT_BLOCKING_STOREFILE_COUNT`
`static int`	`DEFAULT_COMPACTCHECKER_INTERVAL_MULTIPLIER`
`private static int`	`DEFAULT_FLUSH_RETRIES_NUMBER`
`private HColumnDescriptor`	`family`
`private List<StoreFile>`	`filesCompacting`
`static long`	`FIXED_OVERHEAD`
`private long`	`flushedCellsCount`
`private long`	`flushedCellsSize`
`private int`	`flushRetriesNumber`
`(package private) boolean`	`forceMajor`
`private HRegionFileSystem`	`fs`
`private long`	`lastCompactSize`
`(package private) ReentrantReadWriteLock`	`lock` RWLock for store operations.
`private static org.apache.commons.logging.Log`	`LOG`
`private long`	`majorCompactedCellsCount`
`private long`	`majorCompactedCellsSize`
`protected MemStore`	`memstore`
`private static String`	`MEMSTORE_CLASS_NAME`
`private static AtomicBoolean`	`offPeakCompactionTracker`
`private OffPeakHours`	`offPeakHours`
`private int`	`pauseTime`
`private HRegion`	`region`
`private ScanInfo`	`scanInfo`
`(package private) StoreEngine<?,?,?,?>`	`storeEngine`
`private long`	`storeSize`
`private long`	`totalUncompressedBytes`
`private boolean`	`verifyBulkLoads`

Fields inherited from interface org.apache.hadoop.hbase.regionserver.Store
NO_PRIORITY, PRIORITY_USER

Constructor Summary

Constructors
Modifier Constructor and Description

protected HStore(HRegion region, HColumnDescriptor family, org.apache.hadoop.conf.Configuration confParam)
Constructor

Constructors
Modifier	Constructor and Description
`protected`	`HStore(HRegion region, HColumnDescriptor family, org.apache.hadoop.conf.Configuration confParam)` Constructor

Method Summary

Methods
Modifier and Type	Method and Description
`long`	`add(Cell cell)` Adds a value to the memstore
`void`	`addChangedReaderObserver(ChangedReadersObserver o)`
`private void`	`addToCompactingFiles(Collection<StoreFile> filesToAdd)` Adds the files to compacting files.
`boolean`	`areWritesEnabled()`
`void`	`assertBulkLoadHFileOk(org.apache.hadoop.fs.Path srcPath)` This throws a WrongRegionException if the HFile does not fit in this region, or an InvalidHFileException if the HFile is not valid.
`private void`	`bulkLoadHFile(StoreFile sf)`
`void`	`bulkLoadHFile(StoreFileInfo fileInfo)`
`org.apache.hadoop.fs.Path`	`bulkLoadHFile(String srcPathStr, long seqNum)` This method should only be called from Region.
`void`	`cancelRequestedCompaction(CompactionContext compaction)`
`boolean`	`canSplit()`
`com.google.common.collect.ImmutableCollection<StoreFile>`	`close()` Close all the readers We don't need to worry about subsequent requests because the Region holds a write lock that will prevent any more reads or writes.
`private StoreFile`	`commitFile(org.apache.hadoop.fs.Path path, long logCacheFlushId, MonitoredTask status)`
`List<StoreFile>`	`compact(CompactionContext compaction, CompactionThroughputController throughputController)` Compact the StoreFiles.
`List<StoreFile>`	`compact(CompactionContext compaction, CompactionThroughputController throughputController, User user)`
`void`	`compactRecentForTestingAssumingDefaultPolicy(int N)` This method tries to compact N recent files for testing.
`protected void`	`completeCompaction(Collection<StoreFile> compactedFiles)` It works by processing a compaction that's been written to disk.
`protected void`	`completeCompaction(Collection<StoreFile> compactedFiles, boolean removeFiles)` It works by processing a compaction that's been written to disk.
`private HFileContext`	`createFileContext(Compression.Algorithm compression, boolean includeMVCCReadpoint, boolean includesTag, Encryption.Context cryptoContext)`
`StoreFlushContext`	`createFlushContext(long cacheFlushId)`
`private StoreFile`	`createStoreFileAndReader(org.apache.hadoop.fs.Path p)`
`private StoreFile`	`createStoreFileAndReader(StoreFileInfo info)`
`StoreFile.Writer`	`createWriterInTmp(long maxKeyCount, Compression.Algorithm compression, boolean isCompaction, boolean includeMVCCReadpoint, boolean includesTag)`
`StoreFile.Writer`	`createWriterInTmp(long maxKeyCount, Compression.Algorithm compression, boolean isCompaction, boolean includeMVCCReadpoint, boolean includesTag, boolean shouldDropBehind)`
`protected long`	`delete(KeyValue kv)` Adds a value to the memstore
`void`	`deleteChangedReaderObserver(ChangedReadersObserver o)`
`void`	`deregisterChildren(ConfigurationManager manager)` Needs to be called to deregister the children from the manager.
`private static long`	`determineTTLFromFamily(HColumnDescriptor family)`
`private void`	`finishCompactionRequest(CompactionRequest cr)`
`protected List<org.apache.hadoop.fs.Path>`	`flushCache(long logCacheFlushId, MemStoreSnapshot snapshot, MonitoredTask status)` Write out current snapshot.
`long`	`getBlockingFileCount()` The number of files required before flushes for this store will be blocked.
`static int`	`getBytesPerChecksum(org.apache.hadoop.conf.Configuration conf)` Returns the configured bytesPerChecksum value.
`CacheConfig`	`getCacheConfig()` Used for tests.
`static ChecksumType`	`getChecksumType(org.apache.hadoop.conf.Configuration conf)` Returns the configured checksum algorithm.
`static int`	`getCloseCheckInterval()`
`String`	`getColumnFamilyName()`
`long`	`getCompactedCellsCount()`
`long`	`getCompactedCellsSize()`
`long`	`getCompactionCheckMultiplier()`
`double`	`getCompactionPressure()` This value can represent the degree of emergency of compaction for this store.
`CompactionProgress`	`getCompactionProgress()` getter for CompactionProgress object
`int`	`getCompactPriority()`
`KeyValue.KVComparator`	`getComparator()`
`RegionCoprocessorHost`	`getCoprocessorHost()`
`HFileDataBlockEncoder`	`getDataBlockEncoder()`
`HColumnDescriptor`	`getFamily()`
`org.apache.hadoop.fs.FileSystem`	`getFileSystem()`
`long`	`getFlushableSize()`
`long`	`getFlushedCellsCount()`
`long`	`getFlushedCellsSize()`
`HRegion`	`getHRegion()`
`long`	`getLastCompactSize()`
`long`	`getMajorCompactedCellsCount()`
`long`	`getMajorCompactedCellsSize()`
`long`	`getMaxMemstoreTS()`
`long`	`getMaxSequenceId()`
`long`	`getMemstoreFlushSize()`
`long`	`getMemStoreSize()`
`protected OffPeakHours`	`getOffPeakHours()`
`HRegionFileSystem`	`getRegionFileSystem()`
`HRegionInfo`	`getRegionInfo()`
`Cell`	`getRowKeyAtOrBefore(byte[] row)` Find the key that matches row exactly, or the one that immediately precedes it.
`ScanInfo`	`getScanInfo()`
`KeyValueScanner`	`getScanner(Scan scan, NavigableSet<byte[]> targetCols, long readPt)` Return a scanner for both the memstore and the HStore files.
`List<KeyValueScanner>`	`getScanners(boolean cacheBlocks, boolean isGet, boolean usePread, boolean isCompaction, ScanQueryMatcher matcher, byte[] startRow, byte[] stopRow, long readPt)` Get all scanners with no filtering based on TTL (that happens further down the line).
`long`	`getSize()`
`long`	`getSmallestReadPoint()`
`long`	`getSnapshotSize()` Returns the memstore snapshot size
`byte[]`	`getSplitPoint()` Determines if Store should be split
`StoreEngine<?,?,?,?>`	`getStoreEngine()` Returns the StoreEngine that is backing this concrete implementation of Store.
`Collection<StoreFile>`	`getStorefiles()`
`int`	`getStorefilesCount()`
`long`	`getStorefilesIndexSize()`
`long`	`getStorefilesSize()`
`long`	`getStoreFileTtl()`
`static org.apache.hadoop.fs.Path`	`getStoreHomedir(org.apache.hadoop.fs.Path tabledir, HRegionInfo hri, byte[] family)` Deprecated.
`static org.apache.hadoop.fs.Path`	`getStoreHomedir(org.apache.hadoop.fs.Path tabledir, String encodedName, byte[] family)` Deprecated.
`long`	`getStoreSizeUncompressed()`
`TableName`	`getTableName()`
`long`	`getTotalStaticBloomSize()` Returns the total byte size of all Bloom filter bit arrays.
`long`	`getTotalStaticIndexSize()` Returns the total size of all index blocks in the data block indexes, including the root level, intermediate levels, and the leaf level for multi-level indexes, or just the root level for single-level indexes.
`boolean`	`hasReferences()`
`boolean`	`hasTooManyStoreFiles()`
`long`	`heapSize()`
`(package private) static boolean`	`isCellTTLExpired(Cell cell, long oldestTimestamp, long now)`
`boolean`	`isMajorCompaction()`
`boolean`	`isPrimaryReplicaStore()`
`private List<StoreFile>`	`loadStoreFiles()` Creates an unsorted list of StoreFile loaded in parallel from the given directory.
`private void`	`logCompactionEndMessage(CompactionRequest cr, List<StoreFile> sfs, long compactionStartTime)` Log a very elaborate compaction completion message.
`private List<StoreFile>`	`moveCompatedFilesIntoPlace(CompactionRequest cr, List<org.apache.hadoop.fs.Path> newFiles, User user)`
`(package private) StoreFile`	`moveFileIntoPlace(org.apache.hadoop.fs.Path newFile)`
`boolean`	`needsCompaction()` See if there's too much store files in this store
`private void`	`notifyChangedReadersObservers()`
`void`	`onConfigurationChange(org.apache.hadoop.conf.Configuration conf)` This method would be called by the `ConfigurationManager` object when the `Configuration` object is reloaded from disk.
`private List<StoreFile>`	`openStoreFiles(Collection<StoreFileInfo> files)`
`void`	`refreshStoreFiles()` Checks the underlying store files, and opens the files that have not been opened, and removes the store file readers for store files no longer available.
`void`	`refreshStoreFiles(Collection<String> newFiles)` Replaces the store files that the store has with the given files.
`private void`	`refreshStoreFilesInternal(Collection<StoreFileInfo> newFiles)` Checks the underlying store files, and opens the files that have not been opened, and removes the store file readers for store files no longer available.
`void`	`registerChildren(ConfigurationManager manager)` Needs to be called to register the children to the manager.
`private void`	`removeUnneededFiles()`
`(package private) void`	`replaceStoreFiles(Collection<StoreFile> compactedFiles, Collection<StoreFile> result)`
`void`	`replayCompactionMarker(org.apache.hadoop.hbase.protobuf.generated.WALProtos.CompactionDescriptor compaction, boolean pickCompactionFiles, boolean removeFiles)` Call to complete a compaction.
`CompactionContext`	`requestCompaction()`
`CompactionContext`	`requestCompaction(int priority, CompactionRequest baseRequest)`
`CompactionContext`	`requestCompaction(int priority, CompactionRequest baseRequest, User user)`
`void`	`rollback(Cell cell)` Removes a Cell from the memstore.
`private boolean`	`rowAtOrBeforeFromStoreFile(StoreFile f, GetClosestRowBeforeTracker state)`
`private boolean`	`seekToScanner(HFileScanner scanner, KeyValue firstOnRow, KeyValue firstKV)`
`(package private) void`	`setDataBlockEncoderInTest(HFileDataBlockEncoder blockEncoder)` Should be used only in tests.
`(package private) void`	`setScanInfo(ScanInfo scanInfo)` Set scan info, used by test
`(package private) void`	`snapshot()` Snapshot this stores memstore.
`boolean`	`throttleCompaction(long compactionSize)`
`long`	`timeOfOldestEdit()` When was the last edit done in the memstore
`String`	`toString()`
`void`	`triggerMajorCompaction()`
`long`	`updateColumnValue(byte[] row, byte[] f, byte[] qualifier, long newValue)` Used in tests.
`private boolean`	`updateStorefiles(List<StoreFile> sfs, long snapshotId)`
`long`	`upsert(Iterable<Cell> cells, long readpoint)` Adds or replaces the specified KeyValues.
`private void`	`validateStoreFile(org.apache.hadoop.fs.Path path)` Validates a store file by opening and closing it.
`(package private) int`	`versionsToReturn(int wantedVersions)`
`private boolean`	`walkForwardInSingleRow(HFileScanner scanner, KeyValue firstOnRow, GetClosestRowBeforeTracker state)`
`private void`	`writeCompactionWalRecord(Collection<StoreFile> filesCompacted, Collection<StoreFile> newFiles)` Writes the compaction WAL record.

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

- Field Detail
  - MEMSTORE_CLASS_NAME
```
private static final String MEMSTORE_CLASS_NAME
```
    See Also:
    Constant Field Values
  - COMPACTCHECKER_INTERVAL_MULTIPLIER_KEY
```
public static final String COMPACTCHECKER_INTERVAL_MULTIPLIER_KEY
```
    See Also:
    Constant Field Values
  - BLOCKING_STOREFILES_KEY
```
public static final String BLOCKING_STOREFILES_KEY
```
    See Also:
    Constant Field Values
  - DEFAULT_COMPACTCHECKER_INTERVAL_MULTIPLIER
```
public static final int DEFAULT_COMPACTCHECKER_INTERVAL_MULTIPLIER
```
    See Also:
    Constant Field Values
  - DEFAULT_BLOCKING_STOREFILE_COUNT
```
public static final int DEFAULT_BLOCKING_STOREFILE_COUNT
```
    See Also:
    Constant Field Values
  - LOG
```
private static final org.apache.commons.logging.Log LOG
```
  - memstore
```
protected final MemStore memstore
```
  - region
```
private final HRegion region
```
  - family
```
private final HColumnDescriptor family
```
  - fs
```
private final HRegionFileSystem fs
```
  - conf
```
private org.apache.hadoop.conf.Configuration conf
```
  - cacheConf
```
private final CacheConfig cacheConf
```
  - lastCompactSize
```
private long lastCompactSize
```
  - forceMajor
```
volatile boolean forceMajor
```
  - closeCheckInterval
```
static int closeCheckInterval
```
  - storeSize
```
private volatile long storeSize
```
  - totalUncompressedBytes
```
private volatile long totalUncompressedBytes
```
  - lock
```
final ReentrantReadWriteLock lock
```
    RWLock for store operations. Locked in shared mode when the list of component stores is looked at: - all reads/writes to table data - checking for split Locked in exclusive mode when the list of component stores is modified: - closing - completing a compaction
  - verifyBulkLoads
```
private final boolean verifyBulkLoads
```
  - scanInfo
```
private ScanInfo scanInfo
```
  - filesCompacting
```
private final List<StoreFile> filesCompacting
```
  - changedReaderObservers
```
private final Set<ChangedReadersObserver> changedReaderObservers
```
  - blocksize
```
private final int blocksize
```
  - dataBlockEncoder
```
private HFileDataBlockEncoder dataBlockEncoder
```
  - checksumType
```
private ChecksumType checksumType
```
    Checksum configuration
  - bytesPerChecksum
```
private int bytesPerChecksum
```
  - comparator
```
private final KeyValue.KVComparator comparator
```
  - storeEngine
```
final StoreEngine<?,?,?,?> storeEngine
```
  - offPeakCompactionTracker
```
private static final AtomicBoolean offPeakCompactionTracker
```
  - offPeakHours
```
private volatile OffPeakHours offPeakHours
```
  - DEFAULT_FLUSH_RETRIES_NUMBER
```
private static final int DEFAULT_FLUSH_RETRIES_NUMBER
```
    See Also:
    Constant Field Values
  - flushRetriesNumber
```
private int flushRetriesNumber
```
  - pauseTime
```
private int pauseTime
```
  - blockingFileCount
```
private long blockingFileCount
```
  - compactionCheckMultiplier
```
private int compactionCheckMultiplier
```
  - cryptoContext
```
private Encryption.Context cryptoContext
```
  - flushedCellsCount
```
private volatile long flushedCellsCount
```
  - compactedCellsCount
```
private volatile long compactedCellsCount
```
  - majorCompactedCellsCount
```
private volatile long majorCompactedCellsCount
```
  - flushedCellsSize
```
private volatile long flushedCellsSize
```
  - compactedCellsSize
```
private volatile long compactedCellsSize
```
  - majorCompactedCellsSize
```
private volatile long majorCompactedCellsSize
```
  - FIXED_OVERHEAD
```
public static final long FIXED_OVERHEAD
```
  - DEEP_OVERHEAD
```
public static final long DEEP_OVERHEAD
```
- Constructor Detail
  - HStore
```
protected HStore(HRegion region,
      HColumnDescriptor family,
      org.apache.hadoop.conf.Configuration confParam)
          throws IOException
```
    Constructor
    
    Parameters:
    region -
    family - HColumnDescriptor for this column
    confParam - configuration object failed. Can be null.
    
    Throws:
    
    IOException
- Method Detail
  - determineTTLFromFamily
```
private static long determineTTLFromFamily(HColumnDescriptor family)
```
    Parameters:
    family -
    
    Returns:
    TTL in seconds of the specified family
  - getColumnFamilyName
```
public String getColumnFamilyName()
```
    Specified by:
    
    getColumnFamilyName in interface Store
  - getTableName
```
public TableName getTableName()
```
    Specified by:
    
    getTableName in interface Store
  - getFileSystem
```
public org.apache.hadoop.fs.FileSystem getFileSystem()
```
    Specified by:
    
    getFileSystem in interface Store
  - getRegionFileSystem
```
public HRegionFileSystem getRegionFileSystem()
```
  - getStoreFileTtl
```
public long getStoreFileTtl()
```
    Specified by:
    
    getStoreFileTtl in interface StoreConfigInformation
    
    Returns:
    Gets the cf-specific time-to-live for store files.
  - getMemstoreFlushSize
```
public long getMemstoreFlushSize()
```
    Specified by:
    
    getMemstoreFlushSize in interface StoreConfigInformation
    
    Returns:
    Gets the Memstore flush size for the region that this store works with.
  - getFlushableSize
```
public long getFlushableSize()
```
    Specified by:
    
    getFlushableSize in interface Store
    
    Returns:
    The amount of memory we could flush from this memstore; usually this is equal to Store.getMemStoreSize() unless we are carrying snapshots and then it will be the size of outstanding snapshots.
  - getSnapshotSize
```
public long getSnapshotSize()
```
    Description copied from interface: Store
    
    Returns the memstore snapshot size
    
    Specified by:
    
    getSnapshotSize in interface Store
    
    Returns:
    size of the memstore snapshot
  - getCompactionCheckMultiplier
```
public long getCompactionCheckMultiplier()
```
    Specified by:
    
    getCompactionCheckMultiplier in interface StoreConfigInformation
    
    Returns:
    Gets the cf-specific compaction check frequency multiplier. The need for compaction (outside of normal checks during flush, open, etc.) will be ascertained every multiplier * HConstants.THREAD_WAKE_FREQUENCY milliseconds.
  - getBlockingFileCount
```
public long getBlockingFileCount()
```
    Description copied from interface: StoreConfigInformation
    
    The number of files required before flushes for this store will be blocked.
    
    Specified by:
    
    getBlockingFileCount in interface StoreConfigInformation
  - getBytesPerChecksum
```
public static int getBytesPerChecksum(org.apache.hadoop.conf.Configuration conf)
```
    Returns the configured bytesPerChecksum value.
    
    Parameters:
    conf - The configuration
    
    Returns:
    The bytesPerChecksum that is set in the configuration
  - getChecksumType
```
public static ChecksumType getChecksumType(org.apache.hadoop.conf.Configuration conf)
```
    Returns the configured checksum algorithm.
    
    Parameters:
    conf - The configuration
    
    Returns:
    The checksum algorithm that is set in the configuration
  - getCloseCheckInterval
```
public static int getCloseCheckInterval()
```
    Returns:
    how many bytes to write between status checks
  - getFamily
```
public HColumnDescriptor getFamily()
```
    Specified by:
    
    getFamily in interface Store
  - getMaxSequenceId
```
public long getMaxSequenceId()
```
    Specified by:
    
    getMaxSequenceId in interface Store
    
    Returns:
    The maximum sequence id in all store files. Used for log replay.
  - getMaxMemstoreTS
```
public long getMaxMemstoreTS()
```
    Specified by:
    
    getMaxMemstoreTS in interface Store
    
    Returns:
    The maximum memstoreTS in all store files.
  - getStoreHomedir
```
@Deprecated
public static org.apache.hadoop.fs.Path getStoreHomedir(org.apache.hadoop.fs.Path tabledir,
                                                   HRegionInfo hri,
                                                   byte[] family)
```
    Deprecated.
    
    Parameters:
    tabledir - Path to where the table is being stored
    hri - HRegionInfo for the region.
    family - HColumnDescriptor describing the column family
    
    Returns:
    Path to family/Store home directory.
  - getStoreHomedir
```
@Deprecated
public static org.apache.hadoop.fs.Path getStoreHomedir(org.apache.hadoop.fs.Path tabledir,
                                                   String encodedName,
                                                   byte[] family)
```
    Deprecated.
    
    Parameters:
    tabledir - Path to where the table is being stored
    encodedName - Encoded region name.
    family - HColumnDescriptor describing the column family
    
    Returns:
    Path to family/Store home directory.
  - getDataBlockEncoder
```
public HFileDataBlockEncoder getDataBlockEncoder()
```
    Specified by:
    
    getDataBlockEncoder in interface Store
    
    Returns:
    the data block encoder
  - setDataBlockEncoderInTest
```
void setDataBlockEncoderInTest(HFileDataBlockEncoder blockEncoder)
```
    Should be used only in tests.
    
    Parameters:
    blockEncoder - the block delta encoder to use
  - loadStoreFiles
```
private List<StoreFile> loadStoreFiles()
                                throws IOException
```
    Creates an unsorted list of StoreFile loaded in parallel from the given directory.
    
    Throws:
    
    IOException
  - openStoreFiles
```
private List<StoreFile> openStoreFiles(Collection<StoreFileInfo> files)
                                throws IOException
```
    Throws:
    
    IOException
  - refreshStoreFiles
```
public void refreshStoreFiles()
                       throws IOException
```
    Checks the underlying store files, and opens the files that have not been opened, and removes the store file readers for store files no longer available. Mainly used by secondary region replicas to keep up to date with the primary region files.
    
    Specified by:
    
    refreshStoreFiles in interface Store
    
    Throws:
    
    IOException
  - refreshStoreFiles
```
public void refreshStoreFiles(Collection<String> newFiles)
                       throws IOException
```
    Description copied from interface: Store
    
    Replaces the store files that the store has with the given files. Mainly used by secondary region replicas to keep up to date with the primary region files.
    
    Specified by:
    
    refreshStoreFiles in interface Store
    
    Throws:
    
    IOException
  - refreshStoreFilesInternal
```
private void refreshStoreFilesInternal(Collection<StoreFileInfo> newFiles)
                                throws IOException
```
    Checks the underlying store files, and opens the files that have not been opened, and removes the store file readers for store files no longer available. Mainly used by secondary region replicas to keep up to date with the primary region files.
    
    Throws:
    
    IOException
  - createStoreFileAndReader
```
private StoreFile createStoreFileAndReader(org.apache.hadoop.fs.Path p)
                                    throws IOException
```
    Throws:
    
    IOException
  - createStoreFileAndReader
```
private StoreFile createStoreFileAndReader(StoreFileInfo info)
                                    throws IOException
```
    Throws:
    
    IOException
  - add
```
public long add(Cell cell)
```
    Description copied from interface: Store
    
    Adds a value to the memstore
    
    Specified by:
    
    add in interface Store
    
    Returns:
    memstore size delta
  - timeOfOldestEdit
```
public long timeOfOldestEdit()
```
    Description copied from interface: Store
    
    When was the last edit done in the memstore
    
    Specified by:
    
    timeOfOldestEdit in interface Store
  - delete
```
protected long delete(KeyValue kv)
```
    Adds a value to the memstore
    
    Parameters:
    kv -
    
    Returns:
    memstore size delta
  - rollback
```
public void rollback(Cell cell)
```
    Description copied from interface: Store
    
    Removes a Cell from the memstore. The Cell is removed only if its key & memstoreTS match the key & memstoreTS value of the cell parameter.
    
    Specified by:
    
    rollback in interface Store
  - getStorefiles
```
public Collection<StoreFile> getStorefiles()
```
    Specified by:
    
    getStorefiles in interface Store
    
    Returns:
    All store files.
  - assertBulkLoadHFileOk
```
public void assertBulkLoadHFileOk(org.apache.hadoop.fs.Path srcPath)
                           throws IOException
```
    Description copied from interface: Store
    
    This throws a WrongRegionException if the HFile does not fit in this region, or an InvalidHFileException if the HFile is not valid.
    
    Specified by:
    
    assertBulkLoadHFileOk in interface Store
    
    Throws:
    
    IOException
  - bulkLoadHFile
```
public org.apache.hadoop.fs.Path bulkLoadHFile(String srcPathStr,
                                      long seqNum)
                                        throws IOException
```
    Description copied from interface: Store
    
    This method should only be called from Region. It is assumed that the ranges of values in the HFile fit within the stores assigned region. (assertBulkLoadHFileOk checks this)
    
    Specified by:
    
    bulkLoadHFile in interface Store
    
    seqNum - sequence Id associated with the HFile
    
    Throws:
    
    IOException
  - bulkLoadHFile
```
public void bulkLoadHFile(StoreFileInfo fileInfo)
                   throws IOException
```
    Specified by:
    
    bulkLoadHFile in interface Store
    
    Throws:
    
    IOException
  - bulkLoadHFile
```
private void bulkLoadHFile(StoreFile sf)
                    throws IOException
```
    Throws:
    
    IOException
  - close
```
public com.google.common.collect.ImmutableCollection<StoreFile> close()
                                                               throws IOException
```
    Description copied from interface: Store
    
    Close all the readers We don't need to worry about subsequent requests because the Region holds a write lock that will prevent any more reads or writes.
    
    Specified by:
    
    close in interface Store
    
    Returns:
    the StoreFiles that were previously being used.
    
    Throws:
    
    IOException - on failure
  - snapshot
```
void snapshot()
```
    Snapshot this stores memstore. Call before running flushCache(long, MemStoreSnapshot, MonitoredTask) so it has some work to do.
  - flushCache
```
protected List<org.apache.hadoop.fs.Path> flushCache(long logCacheFlushId,
                                         MemStoreSnapshot snapshot,
                                         MonitoredTask status)
                                              throws IOException
```
    Write out current snapshot. Presumes snapshot() has been called previously.
    
    Parameters:
    logCacheFlushId - flush sequence number
    snapshot -
    status -
    
    Returns:
    The path name of the tmp file to which the store was flushed
    
    Throws:
    
    IOException
  - commitFile
```
private StoreFile commitFile(org.apache.hadoop.fs.Path path,
                   long logCacheFlushId,
                   MonitoredTask status)
                      throws IOException
```
    Throws:
    
    IOException
  - createWriterInTmp
```
public StoreFile.Writer createWriterInTmp(long maxKeyCount,
                                 Compression.Algorithm compression,
                                 boolean isCompaction,
                                 boolean includeMVCCReadpoint,
                                 boolean includesTag)
                                   throws IOException
```
    Specified by:
    
    createWriterInTmp in interface Store
    
    compression - Compression algorithm to use
    isCompaction - whether we are creating a new file in a compaction
    includeMVCCReadpoint - whether we should out the MVCC readpoint
    
    Returns:
    Writer for a new StoreFile in the tmp dir.
    
    Throws:
    
    IOException
  - createWriterInTmp
```
public StoreFile.Writer createWriterInTmp(long maxKeyCount,
                                 Compression.Algorithm compression,
                                 boolean isCompaction,
                                 boolean includeMVCCReadpoint,
                                 boolean includesTag,
                                 boolean shouldDropBehind)
                                   throws IOException
```
    Specified by:
    
    createWriterInTmp in interface Store
    
    compression - Compression algorithm to use
    isCompaction - whether we are creating a new file in a compaction
    includeMVCCReadpoint - whether we should out the MVCC readpoint
    shouldDropBehind - should the writer drop caches behind writes
    
    Returns:
    Writer for a new StoreFile in the tmp dir.
    
    Throws:
    
    IOException
  - createFileContext
```
private HFileContext createFileContext(Compression.Algorithm compression,
                             boolean includeMVCCReadpoint,
                             boolean includesTag,
                             Encryption.Context cryptoContext)
```
  - updateStorefiles
```
private boolean updateStorefiles(List<StoreFile> sfs,
                       long snapshotId)
                          throws IOException
```
    Throws:
    
    IOException
  - notifyChangedReadersObservers
```
private void notifyChangedReadersObservers()
                                    throws IOException
```
    Throws:
    
    IOException
  - getScanners
```
public List<KeyValueScanner> getScanners(boolean cacheBlocks,
                                boolean isGet,
                                boolean usePread,
                                boolean isCompaction,
                                ScanQueryMatcher matcher,
                                byte[] startRow,
                                byte[] stopRow,
                                long readPt)
                                  throws IOException
```
    Get all scanners with no filtering based on TTL (that happens further down the line).
    
    Specified by:
    
    getScanners in interface Store
    
    Returns:
    all scanners for this store
    
    Throws:
    
    IOException
  - addChangedReaderObserver
```
public void addChangedReaderObserver(ChangedReadersObserver o)
```
    Specified by:
    
    addChangedReaderObserver in interface Store
  - deleteChangedReaderObserver
```
public void deleteChangedReaderObserver(ChangedReadersObserver o)
```
    Specified by:
    
    deleteChangedReaderObserver in interface Store
  - compact
```
public List<StoreFile> compact(CompactionContext compaction,
                      CompactionThroughputController throughputController)
                        throws IOException
```
    Compact the StoreFiles. This method may take some time, so the calling thread must be able to block for long periods.
    During this time, the Store can work as usual, getting values from StoreFiles and writing new StoreFiles from the memstore. Existing StoreFiles are not destroyed until the new compacted StoreFile is completely written-out to disk.
    The compactLock prevents multiple simultaneous compactions. The structureLock prevents us from interfering with other write operations.
    We don't want to hold the structureLock for the whole time, as a compact() can be lengthy and we want to allow cache-flushes during this period.
    Compaction event should be idempotent, since there is no IO Fencing for the region directory in hdfs. A region server might still try to complete the compaction after it lost the region. That is why the following events are carefully ordered for a compaction: 1. Compaction writes new files under region/.tmp directory (compaction output) 2. Compaction atomically moves the temporary file under region directory 3. Compaction appends a WAL edit containing the compaction input and output files. Forces sync on WAL. 4. Compaction deletes the input files from the region directory. Failure conditions are handled like this: - If RS fails before 2, compaction wont complete. Even if RS lives on and finishes the compaction later, it will only write the new data file to the region directory. Since we already have this data, this will be idempotent but we will have a redundant copy of the data. - If RS fails between 2 and 3, the region will have a redundant copy of the data. The RS that failed won't be able to finish snyc() for WAL because of lease recovery in WAL. - If RS fails after 3, the region region server who opens the region will pick up the the compaction marker from the WAL and replay it by removing the compaction input files. Failed RS can also attempt to delete those files, but the operation will be idempotent See HBASE-2231 for details.
    
    Specified by:
    
    compact in interface Store
    
    Parameters:
    compaction - compaction details obtained from requestCompaction()
    
    Returns:
    Storefile we compacted into or null if we failed or opted out early.
    
    Throws:
    
    IOException
  - compact
```
public List<StoreFile> compact(CompactionContext compaction,
                      CompactionThroughputController throughputController,
                      User user)
                        throws IOException
```
    Specified by:
    
    compact in interface Store
    
    Throws:
    
    IOException
  - moveCompatedFilesIntoPlace
```
private List<StoreFile> moveCompatedFilesIntoPlace(CompactionRequest cr,
                                         List<org.apache.hadoop.fs.Path> newFiles,
                                         User user)
                                            throws IOException
```
    Throws:
    
    IOException
  - moveFileIntoPlace
```
StoreFile moveFileIntoPlace(org.apache.hadoop.fs.Path newFile)
                      throws IOException
```
    Throws:
    
    IOException
  - writeCompactionWalRecord
```
private void writeCompactionWalRecord(Collection<StoreFile> filesCompacted,
                            Collection<StoreFile> newFiles)
                               throws IOException
```
    Writes the compaction WAL record.
    
    Parameters:
    filesCompacted - Files compacted (input).
    newFiles - Files from compaction.
    
    Throws:
    
    IOException
  - replaceStoreFiles
```
void replaceStoreFiles(Collection<StoreFile> compactedFiles,
                     Collection<StoreFile> result)
                 throws IOException
```
    Throws:
    
    IOException
  - logCompactionEndMessage
```
private void logCompactionEndMessage(CompactionRequest cr,
                           List<StoreFile> sfs,
                           long compactionStartTime)
```
    Log a very elaborate compaction completion message.
    
    Parameters:
    cr - Request.
    sfs - Resulting files.
    compactionStartTime - Start time.
  - replayCompactionMarker
```
public void replayCompactionMarker(org.apache.hadoop.hbase.protobuf.generated.WALProtos.CompactionDescriptor compaction,
                          boolean pickCompactionFiles,
                          boolean removeFiles)
                            throws IOException
```
    Call to complete a compaction. Its for the case where we find in the WAL a compaction that was not finished. We could find one recovering a WAL after a regionserver crash. See HBASE-2231.
    
    Specified by:
    
    replayCompactionMarker in interface Store
    
    Parameters:
    compaction -
    pickCompactionFiles - whether or not pick up the new compaction output files and add it to the store
    removeFiles - whether to remove/archive files from filesystem
    
    Throws:
    
    IOException
  - compactRecentForTestingAssumingDefaultPolicy
```
public void compactRecentForTestingAssumingDefaultPolicy(int N)
                                                  throws IOException
```
    This method tries to compact N recent files for testing. Note that because compacting "recent" files only makes sense for some policies, e.g. the default one, it assumes default policy is used. It doesn't use policy, but instead makes a compaction candidate list by itself.
    
    Parameters:
    N - Number of files.
    
    Throws:
    
    IOException
  - hasReferences
```
public boolean hasReferences()
```
    Specified by:
    
    hasReferences in interface Store
    
    Returns:
    true if the store has any underlying reference files to older HFiles
  - getCompactionProgress
```
public CompactionProgress getCompactionProgress()
```
    Description copied from interface: Store
    
    getter for CompactionProgress object
    
    Specified by:
    
    getCompactionProgress in interface Store
    
    Returns:
    CompactionProgress object; can be null
  - isMajorCompaction
```
public boolean isMajorCompaction()
                          throws IOException
```
    Specified by:
    
    isMajorCompaction in interface Store
    
    Returns:
    true if we should run a major compaction.
    
    Throws:
    
    IOException
  - requestCompaction
```
public CompactionContext requestCompaction()
                                    throws IOException
```
    Specified by:
    
    requestCompaction in interface Store
    
    Throws:
    
    IOException
  - requestCompaction
```
public CompactionContext requestCompaction(int priority,
                                  CompactionRequest baseRequest)
                                    throws IOException
```
    Specified by:
    
    requestCompaction in interface Store
    
    Throws:
    
    IOException
  - requestCompaction
```
public CompactionContext requestCompaction(int priority,
                                  CompactionRequest baseRequest,
                                  User user)
                                    throws IOException
```
    Specified by:
    
    requestCompaction in interface Store
    
    Throws:
    
    IOException
  - addToCompactingFiles
```
private void addToCompactingFiles(Collection<StoreFile> filesToAdd)
```
    Adds the files to compacting files. filesCompacting must be locked.
  - removeUnneededFiles
```
private void removeUnneededFiles()
                          throws IOException
```
    Throws:
    
    IOException
  - cancelRequestedCompaction
```
public void cancelRequestedCompaction(CompactionContext compaction)
```
    Specified by:
    
    cancelRequestedCompaction in interface Store
  - finishCompactionRequest
```
private void finishCompactionRequest(CompactionRequest cr)
```
  - validateStoreFile
```
private void validateStoreFile(org.apache.hadoop.fs.Path path)
                        throws IOException
```
    Validates a store file by opening and closing it. In HFileV2 this should not be an expensive operation.
    
    Parameters:
    path - the path to the store file
    
    Throws:
    
    IOException
  - completeCompaction
```
protected void completeCompaction(Collection<StoreFile> compactedFiles)
                           throws IOException
```
    It works by processing a compaction that's been written to disk.
    It is usually invoked at the end of a compaction, but might also be invoked at HStore startup, if the prior execution died midway through.
    Moving the compacted TreeMap into place means:
```
 1) Unload all replaced StoreFile, close and collect list to delete.
 2) Compute new store size
 
```
    Parameters:
    compactedFiles - list of files that were compacted
    
    Throws:
    
    IOException
  - completeCompaction
```
protected void completeCompaction(Collection<StoreFile> compactedFiles,
                      boolean removeFiles)
                           throws IOException
```
    It works by processing a compaction that's been written to disk.
    It is usually invoked at the end of a compaction, but might also be invoked at HStore startup, if the prior execution died midway through.
    Moving the compacted TreeMap into place means:
```
 1) Unload all replaced StoreFile, close and collect list to delete.
 2) Compute new store size
 
```
    Parameters:
    compactedFiles - list of files that were compacted
    
    Throws:
    
    IOException
  - versionsToReturn
```
int versionsToReturn(int wantedVersions)
```
  - isCellTTLExpired
```
static boolean isCellTTLExpired(Cell cell,
                       long oldestTimestamp,
                       long now)
```
    Parameters:
    cell -
    oldestTimestamp -
    
    Returns:
    true if the cell is expired
  - getRowKeyAtOrBefore
```
public Cell getRowKeyAtOrBefore(byte[] row)
                         throws IOException
```
    Description copied from interface: Store
    
    Find the key that matches row exactly, or the one that immediately precedes it. WARNING: Only use this method on a table where writes occur with strictly increasing timestamps. This method assumes this pattern of writes in order to make it reasonably performant. Also our search is dependent on the axiom that deletes are for cells that are in the container that follows whether a memstore snapshot or a storefile, not for the current container: i.e. we'll see deletes before we come across cells we are to delete. Presumption is that the memstore#kvset is processed before memstore#snapshot and so on.
    
    Specified by:
    
    getRowKeyAtOrBefore in interface Store
    
    Parameters:
    row - The row key of the targeted row.
    
    Returns:
    Found Cell or null if none found.
    
    Throws:
    
    IOException
  - rowAtOrBeforeFromStoreFile
```
private boolean rowAtOrBeforeFromStoreFile(StoreFile f,
                                 GetClosestRowBeforeTracker state)
                                    throws IOException
```
    Throws:
    
    IOException
  - seekToScanner
```
private boolean seekToScanner(HFileScanner scanner,
                    KeyValue firstOnRow,
                    KeyValue firstKV)
                       throws IOException
```
    Throws:
    
    IOException
  - walkForwardInSingleRow
```
private boolean walkForwardInSingleRow(HFileScanner scanner,
                             KeyValue firstOnRow,
                             GetClosestRowBeforeTracker state)
                                throws IOException
```
    Throws:
    
    IOException
  - canSplit
```
public boolean canSplit()
```
    Specified by:
    
    canSplit in interface Store
  - getSplitPoint
```
public byte[] getSplitPoint()
```
    Description copied from interface: Store
    
    Determines if Store should be split
    
    Specified by:
    
    getSplitPoint in interface Store
    
    Returns:
    byte[] if store should be split, null otherwise.
  - getLastCompactSize
```
public long getLastCompactSize()
```
    Specified by:
    
    getLastCompactSize in interface Store
    
    Returns:
    aggregate size of all HStores used in the last compaction
  - getSize
```
public long getSize()
```
    Specified by:
    
    getSize in interface Store
    
    Returns:
    aggregate size of HStore
  - triggerMajorCompaction
```
public void triggerMajorCompaction()
```
    Specified by:
    
    triggerMajorCompaction in interface Store
  - getScanner
```
public KeyValueScanner getScanner(Scan scan,
                         NavigableSet<byte[]> targetCols,
                         long readPt)
                           throws IOException
```
    Description copied from interface: Store
    
    Return a scanner for both the memstore and the HStore files. Assumes we are not in a compaction.
    
    Specified by:
    
    getScanner in interface Store
    
    Parameters:
    scan - Scan to apply when scanning the stores
    targetCols - columns to scan
    
    Returns:
    a scanner over the current key values
    
    Throws:
    
    IOException - on failure
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getStorefilesCount
```
public int getStorefilesCount()
```
    Specified by:
    
    getStorefilesCount in interface Store
    
    Returns:
    Count of store files
  - getStoreSizeUncompressed
```
public long getStoreSizeUncompressed()
```
    Specified by:
    
    getStoreSizeUncompressed in interface Store
    
    Returns:
    The size of the store files, in bytes, uncompressed.
  - getStorefilesSize
```
public long getStorefilesSize()
```
    Specified by:
    
    getStorefilesSize in interface Store
    
    Returns:
    The size of the store files, in bytes.
  - getStorefilesIndexSize
```
public long getStorefilesIndexSize()
```
    Specified by:
    
    getStorefilesIndexSize in interface Store
    
    Returns:
    The size of the store file indexes, in bytes.
  - getTotalStaticIndexSize
```
public long getTotalStaticIndexSize()
```
    Description copied from interface: Store
    
    Returns the total size of all index blocks in the data block indexes, including the root level, intermediate levels, and the leaf level for multi-level indexes, or just the root level for single-level indexes.
    
    Specified by:
    
    getTotalStaticIndexSize in interface Store
    
    Returns:
    the total size of block indexes in the store
  - getTotalStaticBloomSize
```
public long getTotalStaticBloomSize()
```
    Description copied from interface: Store
    
    Returns the total byte size of all Bloom filter bit arrays. For compound Bloom filters even the Bloom blocks currently not loaded into the block cache are counted.
    
    Specified by:
    
    getTotalStaticBloomSize in interface Store
    
    Returns:
    the total size of all Bloom filters in the store
  - getMemStoreSize
```
public long getMemStoreSize()
```
    Specified by:
    
    getMemStoreSize in interface Store
    
    Returns:
    The size of this store's memstore, in bytes
  - getCompactPriority
```
public int getCompactPriority()
```
    Specified by:
    
    getCompactPriority in interface Store
  - throttleCompaction
```
public boolean throttleCompaction(long compactionSize)
```
    Specified by:
    
    throttleCompaction in interface Store
  - getHRegion
```
public HRegion getHRegion()
```
  - getCoprocessorHost
```
public RegionCoprocessorHost getCoprocessorHost()
```
    Specified by:
    
    getCoprocessorHost in interface Store
  - getRegionInfo
```
public HRegionInfo getRegionInfo()
```
    Specified by:
    
    getRegionInfo in interface Store
    
    Returns:
    the parent region info hosting this store
  - areWritesEnabled
```
public boolean areWritesEnabled()
```
    Specified by:
    
    areWritesEnabled in interface Store
  - getSmallestReadPoint
```
public long getSmallestReadPoint()
```
    Specified by:
    
    getSmallestReadPoint in interface Store
    
    Returns:
    The smallest mvcc readPoint across all the scanners in this region. Writes older than this readPoint, are included in every read operation.
  - updateColumnValue
```
public long updateColumnValue(byte[] row,
                     byte[] f,
                     byte[] qualifier,
                     long newValue)
                       throws IOException
```
    Used in tests. TODO: Remove Updates the value for the given row/family/qualifier. This function will always be seen as atomic by other readers because it only puts a single KV to memstore. Thus no read/write control necessary.
    
    Parameters:
    row - row to update
    f - family to update
    qualifier - qualifier to update
    newValue - the new value to set into memstore
    
    Returns:
    memstore size delta
    
    Throws:
    
    IOException
  - upsert
```
public long upsert(Iterable<Cell> cells,
          long readpoint)
            throws IOException
```
    Description copied from interface: Store
    
    Adds or replaces the specified KeyValues.
    For each KeyValue specified, if a cell with the same row, family, and qualifier exists in MemStore, it will be replaced. Otherwise, it will just be inserted to MemStore.
    This operation is atomic on each KeyValue (row/family/qualifier) but not necessarily atomic across all of them.
    
    Specified by:
    
    upsert in interface Store
    
    readpoint - readpoint below which we can safely remove duplicate KVs
    
    Returns:
    memstore size delta
    
    Throws:
    
    IOException
  - createFlushContext
```
public StoreFlushContext createFlushContext(long cacheFlushId)
```
    Specified by:
    
    createFlushContext in interface Store
  - needsCompaction
```
public boolean needsCompaction()
```
    Description copied from interface: Store
    
    See if there's too much store files in this store
    
    Specified by:
    
    needsCompaction in interface Store
    
    Returns:
    true if number of store files is greater than the number defined in minFilesToCompact
  - getCacheConfig
```
public CacheConfig getCacheConfig()
```
    Description copied from interface: Store
    
    Used for tests.
    
    Specified by:
    
    getCacheConfig in interface Store
    
    Returns:
    cache configuration for this Store.
  - heapSize
```
public long heapSize()
```
    Specified by:
    
    heapSize in interface HeapSize
    
    Returns:
    Approximate 'exclusive deep size' of implementing object. Includes count of payload and hosting object sizings.
  - getComparator
```
public KeyValue.KVComparator getComparator()
```
    Specified by:
    
    getComparator in interface Store
  - getScanInfo
```
public ScanInfo getScanInfo()
```
    Specified by:
    
    getScanInfo in interface Store
  - setScanInfo
```
void setScanInfo(ScanInfo scanInfo)
```
    Set scan info, used by test
    
    Parameters:
    scanInfo - new scan info to use for test
  - hasTooManyStoreFiles
```
public boolean hasTooManyStoreFiles()
```
    Specified by:
    
    hasTooManyStoreFiles in interface Store
    
    Returns:
    Whether this store has too many store files.
  - getFlushedCellsCount
```
public long getFlushedCellsCount()
```
    Specified by:
    
    getFlushedCellsCount in interface Store
    
    Returns:
    The number of cells flushed to disk
  - getFlushedCellsSize
```
public long getFlushedCellsSize()
```
    Specified by:
    
    getFlushedCellsSize in interface Store
    
    Returns:
    The total size of data flushed to disk, in bytes
  - getCompactedCellsCount
```
public long getCompactedCellsCount()
```
    Specified by:
    
    getCompactedCellsCount in interface Store
    
    Returns:
    The number of cells processed during minor compactions
  - getCompactedCellsSize
```
public long getCompactedCellsSize()
```
    Specified by:
    
    getCompactedCellsSize in interface Store
    
    Returns:
    The total amount of data processed during minor compactions, in bytes
  - getMajorCompactedCellsCount
```
public long getMajorCompactedCellsCount()
```
    Specified by:
    
    getMajorCompactedCellsCount in interface Store
    
    Returns:
    The number of cells processed during major compactions
  - getMajorCompactedCellsSize
```
public long getMajorCompactedCellsSize()
```
    Specified by:
    
    getMajorCompactedCellsSize in interface Store
    
    Returns:
    The total amount of data processed during major compactions, in bytes
  - getStoreEngine
```
public StoreEngine<?,?,?,?> getStoreEngine()
```
    Returns the StoreEngine that is backing this concrete implementation of Store.
    
    Returns:
    Returns the StoreEngine object used internally inside this HStore object.
  - getOffPeakHours
```
protected OffPeakHours getOffPeakHours()
```
  - onConfigurationChange
```
public void onConfigurationChange(org.apache.hadoop.conf.Configuration conf)
```
    This method would be called by the ConfigurationManager object when the Configuration object is reloaded from disk.
    
    Specified by:
    
    onConfigurationChange in interface ConfigurationObserver
  - registerChildren
```
public void registerChildren(ConfigurationManager manager)
```
    Needs to be called to register the children to the manager.
    
    Specified by:
    
    registerChildren in interface PropagatingConfigurationObserver
    
    Parameters:
    manager - : to register to
  - deregisterChildren
```
public void deregisterChildren(ConfigurationManager manager)
```
    Needs to be called to deregister the children from the manager.
    
    Specified by:
    
    deregisterChildren in interface PropagatingConfigurationObserver
    
    Parameters:
    manager - : to deregister from
  - getCompactionPressure
```
public double getCompactionPressure()
```
    Description copied from interface: Store
    This value can represent the degree of emergency of compaction for this store. It should be greater than or equal to 0.0, any value greater than 1.0 means we have too many store files.
    - if getStorefilesCount <= getMinFilesToCompact, return 0.0
    - return (getStorefilesCount - getMinFilesToCompact) / (blockingFileCount - getMinFilesToCompact)
    And for striped stores, we should calculate this value by the files in each stripe separately and return the maximum value.
    It is similar to Store.getCompactPriority() except that it is more suitable to use in a linear formula.
    Specified by:
    
    getCompactionPressure in interface Store
  - isPrimaryReplicaStore
```
public boolean isPrimaryReplicaStore()
```
    Specified by:
    
    isPrimaryReplicaStore in interface Store

Class HStore

Nested Class Summary

Field Summary

Fields inherited from interface org.apache.hadoop.hbase.regionserver.Store

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MEMSTORE_CLASS_NAME

COMPACTCHECKER_INTERVAL_MULTIPLIER_KEY

BLOCKING_STOREFILES_KEY

DEFAULT_COMPACTCHECKER_INTERVAL_MULTIPLIER

DEFAULT_BLOCKING_STOREFILE_COUNT

LOG

memstore

region

family

fs

conf

cacheConf

lastCompactSize

forceMajor

closeCheckInterval

storeSize

totalUncompressedBytes

lock

verifyBulkLoads

scanInfo

filesCompacting

changedReaderObservers

blocksize

dataBlockEncoder

checksumType

bytesPerChecksum

comparator

storeEngine

offPeakCompactionTracker

offPeakHours

DEFAULT_FLUSH_RETRIES_NUMBER

flushRetriesNumber

pauseTime

blockingFileCount

compactionCheckMultiplier

cryptoContext

flushedCellsCount

compactedCellsCount

majorCompactedCellsCount

flushedCellsSize

compactedCellsSize

majorCompactedCellsSize

FIXED_OVERHEAD

DEEP_OVERHEAD

Constructor Detail

HStore

Method Detail

determineTTLFromFamily

getColumnFamilyName

getTableName

getFileSystem

getRegionFileSystem

getStoreFileTtl

getMemstoreFlushSize

getFlushableSize

getSnapshotSize

getCompactionCheckMultiplier

getBlockingFileCount

getBytesPerChecksum

getChecksumType

getCloseCheckInterval

getFamily

getMaxSequenceId

getMaxMemstoreTS

getStoreHomedir

getStoreHomedir

getDataBlockEncoder

setDataBlockEncoderInTest

loadStoreFiles

openStoreFiles

refreshStoreFiles

refreshStoreFiles