Store (Hortonworks Data Platform Apache HBase Java API Reference)

All Known Implementing Classes:

HMobStore, HStore
```
public interface Store
```
Interface for objects that hold a column family in a Region. Its a memstore and a set of zero or more StoreFiles, which stretch backwards over time.

Field Summary

Fields
Modifier and Type Field and Description

static int NO_PRIORITY

static int PRIORITY_USER
The default priority for user-specified compaction requests.

Fields
Modifier and Type	Field and Description
`static int`	`NO_PRIORITY`
`static int`	`PRIORITY_USER` The default priority for user-specified compaction requests.

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`boolean`	`areWritesEnabled()`
`boolean`	`canSplit()` Returns whether this store is splittable, i.e., no reference file in this store.
`java.util.OptionalDouble`	`getAvgStoreFileAge()`
`ColumnFamilyDescriptor`	`getColumnFamilyDescriptor()`
`java.lang.String`	`getColumnFamilyName()`
`long`	`getCompactedCellsCount()`
`long`	`getCompactedCellsSize()`
`java.util.Collection<? extends StoreFile>`	`getCompactedFiles()`
`int`	`getCompactedFilesCount()`
`double`	`getCompactionPressure()` This value can represent the degree of emergency of compaction for this store.
`int`	`getCompactPriority()`
`CellComparator`	`getComparator()`
`FileSystem`	`getFileSystem()`
`MemStoreSize`	`getFlushableSize()`
`long`	`getFlushedCellsCount()`
`long`	`getFlushedCellsSize()`
`long`	`getFlushedOutputFileSize()`
`long`	`getHFilesSize()`
`long`	`getLastCompactSize()`
`long`	`getMajorCompactedCellsCount()`
`long`	`getMajorCompactedCellsSize()`
`java.util.OptionalLong`	`getMaxMemStoreTS()`
`java.util.OptionalLong`	`getMaxSequenceId()`
`java.util.OptionalLong`	`getMaxStoreFileAge()`
`MemStoreSize`	`getMemStoreSize()`
`java.util.OptionalLong`	`getMinStoreFileAge()`
`long`	`getNumHFiles()`
`long`	`getNumReferenceFiles()`
`RegionInfo`	`getRegionInfo()`
`long`	`getSize()`
`long`	`getSmallestReadPoint()`
`MemStoreSize`	`getSnapshotSize()`
`java.util.Collection<? extends StoreFile>`	`getStorefiles()`
`int`	`getStorefilesCount()`
`long`	`getStorefilesRootLevelIndexSize()`
`long`	`getStorefilesSize()`
`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()`
`boolean`	`isPrimaryReplicaStore()`
`boolean`	`isSloppyMemStore()`
`boolean`	`needsCompaction()` See if there's too much store files in this store
`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.
`boolean`	`shouldPerformMajorCompaction()` Tests whether we should run a major compaction.
`long`	`timeOfOldestEdit()` When was the last edit done in the memstore

- Field Detail
  - PRIORITY_USER
```
static final int PRIORITY_USER
```
    The default priority for user-specified compaction requests. The user gets top priority unless we have blocking compactions. (Pri <= 0)
    
    See Also:
    
    Constant Field Values
  - NO_PRIORITY
```
static final int NO_PRIORITY
```
    See Also:
    
    Constant Field Values
- Method Detail
  - getComparator
```
CellComparator getComparator()
```
  - getStorefiles
```
java.util.Collection<? extends StoreFile> getStorefiles()
```
  - getCompactedFiles
```
java.util.Collection<? extends StoreFile> getCompactedFiles()
```
  - timeOfOldestEdit
```
long timeOfOldestEdit()
```
    When was the last edit done in the memstore
  - getFileSystem
```
FileSystem getFileSystem()
```
  - shouldPerformMajorCompaction
```
boolean shouldPerformMajorCompaction()
                              throws java.io.IOException
```
    Tests whether we should run a major compaction. For example, if the configured major compaction interval is reached.
    
    Returns:
    
    true if we should run a major compaction.
    
    Throws:
    
    java.io.IOException
  - needsCompaction
```
boolean needsCompaction()
```
    See if there's too much store files in this store
    
    Returns:
    
    true if number of store files is greater than the number defined in minFilesToCompact
  - getCompactPriority
```
int getCompactPriority()
```
  - canSplit
```
boolean canSplit()
```
    Returns whether this store is splittable, i.e., no reference file in this store.
  - hasReferences
```
boolean hasReferences()
```
    Returns:
    
    true if the store has any underlying reference files to older HFiles
  - getMemStoreSize
```
MemStoreSize getMemStoreSize()
```
    Returns:
    
    The size of this store's memstore.
  - getFlushableSize
```
MemStoreSize getFlushableSize()
```
    Returns:
    
    The amount of memory we could flush from this memstore; usually this is equal to getMemStoreSize() unless we are carrying snapshots and then it will be the size of outstanding snapshots.
  - getSnapshotSize
```
MemStoreSize getSnapshotSize()
```
    Returns:
    
    size of the memstore snapshot
  - getColumnFamilyDescriptor
```
ColumnFamilyDescriptor getColumnFamilyDescriptor()
```
  - getMaxSequenceId
```
java.util.OptionalLong getMaxSequenceId()
```
    Returns:
    
    The maximum sequence id in all store files.
  - getMaxMemStoreTS
```
java.util.OptionalLong getMaxMemStoreTS()
```
    Returns:
    
    The maximum memstoreTS in all store files.
  - getLastCompactSize
```
long getLastCompactSize()
```
    Returns:
    
    aggregate size of all HStores used in the last compaction
  - getSize
```
long getSize()
```
    Returns:
    
    aggregate size of HStore
  - getStorefilesCount
```
int getStorefilesCount()
```
    Returns:
    
    Count of store files
  - getCompactedFilesCount
```
int getCompactedFilesCount()
```
    Returns:
    
    Count of compacted store files
  - getMaxStoreFileAge
```
java.util.OptionalLong getMaxStoreFileAge()
```
    Returns:
    
    Max age of store files in this store
  - getMinStoreFileAge
```
java.util.OptionalLong getMinStoreFileAge()
```
    Returns:
    
    Min age of store files in this store
  - getAvgStoreFileAge
```
java.util.OptionalDouble getAvgStoreFileAge()
```
    Returns:
    
    Average age of store files in this store
  - getNumReferenceFiles
```
long getNumReferenceFiles()
```
    Returns:
    
    Number of reference files in this store
  - getNumHFiles
```
long getNumHFiles()
```
    Returns:
    
    Number of HFiles in this store
  - getStoreSizeUncompressed
```
long getStoreSizeUncompressed()
```
    Returns:
    
    The size of the store files, in bytes, uncompressed.
  - getStorefilesSize
```
long getStorefilesSize()
```
    Returns:
    
    The size of the store files, in bytes.
  - getHFilesSize
```
long getHFilesSize()
```
    Returns:
    
    The size of only the store files which are HFiles, in bytes.
  - getStorefilesRootLevelIndexSize
```
long getStorefilesRootLevelIndexSize()
```
    Returns:
    
    The size of the store file root-level indexes, in bytes.
  - getTotalStaticIndexSize
```
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.
    
    Returns:
    
    the total size of block indexes in the store
  - getTotalStaticBloomSize
```
long getTotalStaticBloomSize()
```
    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.
    
    Returns:
    
    the total size of all Bloom filters in the store
  - getRegionInfo
```
RegionInfo getRegionInfo()
```
    Returns:
    
    the parent region info hosting this store
  - areWritesEnabled
```
boolean areWritesEnabled()
```
  - getSmallestReadPoint
```
long getSmallestReadPoint()
```
    Returns:
    
    The smallest mvcc readPoint across all the scanners in this region. Writes older than this readPoint, are included in every read operation.
  - getColumnFamilyName
```
java.lang.String getColumnFamilyName()
```
  - getTableName
```
TableName getTableName()
```
  - getFlushedCellsCount
```
long getFlushedCellsCount()
```
    Returns:
    
    The number of cells flushed to disk
  - getFlushedCellsSize
```
long getFlushedCellsSize()
```
    Returns:
    
    The total size of data flushed to disk, in bytes
  - getFlushedOutputFileSize
```
long getFlushedOutputFileSize()
```
    Returns:
    
    The total size of out output files on disk, in bytes
  - getCompactedCellsCount
```
long getCompactedCellsCount()
```
    Returns:
    
    The number of cells processed during minor compactions
  - getCompactedCellsSize
```
long getCompactedCellsSize()
```
    Returns:
    
    The total amount of data processed during minor compactions, in bytes
  - getMajorCompactedCellsCount
```
long getMajorCompactedCellsCount()
```
    Returns:
    
    The number of cells processed during major compactions
  - getMajorCompactedCellsSize
```
long getMajorCompactedCellsSize()
```
    Returns:
    
    The total amount of data processed during major compactions, in bytes
  - hasTooManyStoreFiles
```
boolean hasTooManyStoreFiles()
```
    Returns:
    
    Whether this store has too many store files.
  - refreshStoreFiles
```
void refreshStoreFiles()
                throws java.io.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:
    
    java.io.IOException
  - getCompactionPressure
```
double getCompactionPressure()
```
    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 getCompactPriority() except that it is more suitable to use in a linear formula.
  - isPrimaryReplicaStore
```
boolean isPrimaryReplicaStore()
```
  - isSloppyMemStore
```
boolean isSloppyMemStore()
```
    Returns:
    
    true if the memstore may need some extra memory space

Interface Store

Field Summary

Method Summary

Field Detail

PRIORITY_USER

NO_PRIORITY

Method Detail

getComparator

getStorefiles

getCompactedFiles

timeOfOldestEdit

getFileSystem

shouldPerformMajorCompaction

needsCompaction

getCompactPriority

canSplit

hasReferences

getMemStoreSize

getFlushableSize

getSnapshotSize

getColumnFamilyDescriptor

getMaxSequenceId

getMaxMemStoreTS

getLastCompactSize

getSize

getStorefilesCount

getCompactedFilesCount

getMaxStoreFileAge

getMinStoreFileAge

getAvgStoreFileAge

getNumReferenceFiles

getNumHFiles

getStoreSizeUncompressed

getStorefilesSize

getHFilesSize

getStorefilesRootLevelIndexSize

getTotalStaticIndexSize

getTotalStaticBloomSize

getRegionInfo

areWritesEnabled

getSmallestReadPoint

getColumnFamilyName

getTableName

getFlushedCellsCount

getFlushedCellsSize

getFlushedOutputFileSize

getCompactedCellsCount

getCompactedCellsSize

getMajorCompactedCellsCount

getMajorCompactedCellsSize

hasTooManyStoreFiles

refreshStoreFiles

getCompactionPressure

isPrimaryReplicaStore

isSloppyMemStore