CompactingMemStore (Apache HBase

java.lang.Object
- org.apache.hadoop.hbase.regionserver.AbstractMemStore
- - org.apache.hadoop.hbase.regionserver.CompactingMemStore

所有已实现的接口:

MemStore
```
@InterfaceAudience.Private
public class CompactingMemStore
extends AbstractMemStore
```
A memstore implementation which supports in-memory compaction. A compaction pipeline is added between the active set and the snapshot data structures; it consists of a list of segments that are subject to compaction. Like the snapshot, all pipeline segments are read-only; updates only affect the active set. To ensure this property we take advantage of the existing blocking mechanism -- the active set is pushed to the pipeline while holding the region's updatesLock in exclusive mode. Periodically, a compaction is applied in the background to all pipeline segments resulting in a single read-only component. The ``old'' segments are discarded when no scanner is reading them.

嵌套类概要

嵌套类
限定符和类型	类和说明
`static class`	`CompactingMemStore.IndexType` Types of indexes (part of immutable segments) to be used after flattening, compaction, or merge are applied.

字段概要

字段
限定符和类型	字段和说明
`protected AtomicBoolean`	`allowCompaction`
`static String`	`COMPACTING_MEMSTORE_TYPE_DEFAULT`
`static String`	`COMPACTING_MEMSTORE_TYPE_KEY`
`protected MemStoreCompactor`	`compactor`
`static long`	`DEEP_OVERHEAD`
`static int`	`IN_MEMORY_CONPACTION_POOL_SIZE_DEFAULT`
`static String`	`IN_MEMORY_CONPACTION_POOL_SIZE_KEY`
`static String`	`IN_MEMORY_FLUSH_THRESHOLD_FACTOR_KEY`

从类继承的字段 org.apache.hadoop.hbase.regionserver.AbstractMemStore
FIXED_OVERHEAD, regionServices, snapshot, snapshotId

构造器概要

构造器
构造器和说明
`CompactingMemStore(org.apache.hadoop.conf.Configuration conf, CellComparator c, HStore store, RegionServicesForStores regionServices, MemoryCompactionPolicy compactionPolicy)`

方法概要

所有方法实例方法具体方法
限定符和类型	方法和说明
`protected List<KeyValueScanner>`	`createList(int capacity)`
`protected MemStoreCompactor`	`createMemStoreCompactor(MemoryCompactionPolicy compactionPolicy)`
`void`	`debug()`
`void`	`flattenOneSegment(long requesterVersion, MemStoreCompactionStrategy.Action action)`
`String`	`getFamilyName()`
`MemStoreSize`	`getFlushableSize()` Flush will first clear out the data in snapshot if any (It will take a second flush invocation to clear the current Cell set).
`VersionedSegmentsList`	`getImmutableSegments()`
`CompactingMemStore.IndexType`	`getIndexType()`
`List<KeyValueScanner>`	`getScanners(long readPt)`
`protected List<Segment>`	`getSegments()`
`long`	`getSmallestReadPoint()`
`HStore`	`getStore()`
`boolean`	`hasImmutableSegments()`
`protected long`	`heapSize()`
`boolean`	`isSloppy()`
`protected long`	`keySize()`
`protected void`	`postUpdate(MutableSegment currentActive)` Issue any post update synchronization and tests
`long`	`preFlushSeqIDEstimation()` This method is called before the flush is executed.
`protected boolean`	`preUpdate(MutableSegment currentActive, Cell cell, MemStoreSizing memstoreSizing)` Issue any synchronization and test needed before applying the update For compacting memstore this means checking the update can increase the size without overflow
`protected void`	`pushActiveToPipeline(MutableSegment currActive)`
`void`	`setCompositeSnapshot(boolean useCompositeSnapshot)`
`void`	`setInMemoryCompactionCompleted()`
`protected boolean`	`setInMemoryCompactionFlag()`
`protected boolean`	`shouldFlushInMemory(MutableSegment currActive, Cell cellToAdd, MemStoreSizing memstoreSizing)`
`MemStoreSize`	`size()`
`protected boolean`	`sizeAddedPreOperation()`
`MemStoreSnapshot`	`snapshot()` Push the current active memstore segment into the pipeline and create a snapshot of the tail of current compaction pipeline Snapshot must be cleared by call to `AbstractMemStore.clearSnapshot(long)`.
`void`	`startReplayingFromWAL()` This message intends to inform the MemStore that next coming updates are going to be part of the replaying edits from WAL
`void`	`stopReplayingFromWAL()` This message intends to inform the MemStore that the replaying edits from WAL are done
`boolean`	`swapCompactedSegments(VersionedSegmentsList versionedList, ImmutableSegment result, boolean merge)`
`void`	`updateLowestUnflushedSequenceIdInWAL(boolean onlyIfGreater)` Updates the wal with the lowest sequence id (oldest entry) that is still in memory

从类继承的方法 org.apache.hadoop.hbase.regionserver.AbstractMemStore
add, add, addToScanners, addToScanners, clearSnapshot, dump, getComparator, getConfiguration, getLowest, getNextRow, getSnapshotSize, resetActive, timeOfOldestEdit, toString, upsert

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- 字段详细资料
  - COMPACTING_MEMSTORE_TYPE_KEY
```
public static final String COMPACTING_MEMSTORE_TYPE_KEY
```
    另请参阅:
    
    常量字段值
  - COMPACTING_MEMSTORE_TYPE_DEFAULT
```
public static final String COMPACTING_MEMSTORE_TYPE_DEFAULT
```
  - IN_MEMORY_FLUSH_THRESHOLD_FACTOR_KEY
```
public static final String IN_MEMORY_FLUSH_THRESHOLD_FACTOR_KEY
```
    另请参阅:
    
    常量字段值
  - IN_MEMORY_CONPACTION_POOL_SIZE_KEY
```
public static final String IN_MEMORY_CONPACTION_POOL_SIZE_KEY
```
    另请参阅:
    
    常量字段值
  - IN_MEMORY_CONPACTION_POOL_SIZE_DEFAULT
```
public static final int IN_MEMORY_CONPACTION_POOL_SIZE_DEFAULT
```
    另请参阅:
    
    常量字段值
  - compactor
```
protected MemStoreCompactor compactor
```
  - allowCompaction
```
protected final AtomicBoolean allowCompaction
```
  - DEEP_OVERHEAD
```
public static final long DEEP_OVERHEAD
```
- 构造器详细资料
  - CompactingMemStore
```
public CompactingMemStore(org.apache.hadoop.conf.Configuration conf,
                          CellComparator c,
                          HStore store,
                          RegionServicesForStores regionServices,
                          MemoryCompactionPolicy compactionPolicy)
                   throws IOException
```
    抛出:
    
    IOException
- 方法详细资料
  - createMemStoreCompactor
```
protected MemStoreCompactor createMemStoreCompactor(MemoryCompactionPolicy compactionPolicy)
                                             throws IllegalArgumentIOException
```
    抛出:
    
    IllegalArgumentIOException
  - size
```
public MemStoreSize size()
```
    返回:
    
    Total memory occupied by this MemStore. This won't include any size occupied by the snapshot. We assume the snapshot will get cleared soon. This is not thread safe and the memstore may be changed while computing its size. It is the responsibility of the caller to make sure this doesn't happen.
  - preFlushSeqIDEstimation
```
public long preFlushSeqIDEstimation()
```
    This method is called before the flush is executed.
    
    返回:
    
    an estimation (lower bound) of the unflushed sequence id in memstore after the flush is executed. if memstore will be cleared returns HConstants.NO_SEQNUM.
  - isSloppy
```
public boolean isSloppy()
```
  - snapshot
```
public MemStoreSnapshot snapshot()
```
    Push the current active memstore segment into the pipeline and create a snapshot of the tail of current compaction pipeline Snapshot must be cleared by call to AbstractMemStore.clearSnapshot(long). AbstractMemStore.clearSnapshot(long).
    
    返回:
    
    MemStoreSnapshot
  - getFlushableSize
```
public MemStoreSize getFlushableSize()
```
    从接口复制的说明: MemStore
    
    Flush will first clear out the data in snapshot if any (It will take a second flush invocation to clear the current Cell set). If snapshot is empty, current Cell set will be flushed.
    
    返回:
    
    On flush, how much memory we will clear.
  - setInMemoryCompactionCompleted
```
public void setInMemoryCompactionCompleted()
```
  - setInMemoryCompactionFlag
```
protected boolean setInMemoryCompactionFlag()
```
  - keySize
```
protected long keySize()
```
    指定者:
    
    keySize 在类中 AbstractMemStore
    
    返回:
    
    The total size of cells in this memstore. We will not consider cells in the snapshot
  - heapSize
```
protected long heapSize()
```
    指定者:
    
    heapSize 在类中 AbstractMemStore
    
    返回:
    
    The total heap size of cells in this memstore. We will not consider cells in the snapshot
  - updateLowestUnflushedSequenceIdInWAL
```
public void updateLowestUnflushedSequenceIdInWAL(boolean onlyIfGreater)
```
    从类复制的说明: AbstractMemStore
    
    Updates the wal with the lowest sequence id (oldest entry) that is still in memory
    
    指定者:
    
    updateLowestUnflushedSequenceIdInWAL 在类中 AbstractMemStore
    
    参数:
    
    onlyIfGreater - a flag that marks whether to update the sequence id no matter what or only if it is greater than the previous sequence id
  - startReplayingFromWAL
```
public void startReplayingFromWAL()
```
    This message intends to inform the MemStore that next coming updates are going to be part of the replaying edits from WAL
  - stopReplayingFromWAL
```
public void stopReplayingFromWAL()
```
    This message intends to inform the MemStore that the replaying edits from WAL are done
  - preUpdate
```
protected boolean preUpdate(MutableSegment currentActive,
                            Cell cell,
                            MemStoreSizing memstoreSizing)
```
    Issue any synchronization and test needed before applying the update For compacting memstore this means checking the update can increase the size without overflow
    
    指定者:
    
    preUpdate 在类中 AbstractMemStore
    
    参数:
    
    currentActive - the segment to be updated
    
    cell - the cell to be added
    
    memstoreSizing - object to accumulate region size changes
    
    返回:
    
    true iff can proceed with applying the update
  - postUpdate
```
protected void postUpdate(MutableSegment currentActive)
```
    从类复制的说明: AbstractMemStore
    
    Issue any post update synchronization and tests
    
    指定者:
    
    postUpdate 在类中 AbstractMemStore
    
    参数:
    
    currentActive - updated segment
  - sizeAddedPreOperation
```
protected boolean sizeAddedPreOperation()
```
    指定者:
    
    sizeAddedPreOperation 在类中 AbstractMemStore
  - getSegments
```
protected List<Segment> getSegments()
```
    指定者:
    
    getSegments 在类中 AbstractMemStore
    
    返回:
    
    an ordered list of segments from most recent to oldest in memstore
  - setCompositeSnapshot
```
public void setCompositeSnapshot(boolean useCompositeSnapshot)
```
  - swapCompactedSegments
```
public boolean swapCompactedSegments(VersionedSegmentsList versionedList,
                                     ImmutableSegment result,
                                     boolean merge)
```
  - flattenOneSegment
```
public void flattenOneSegment(long requesterVersion,
                              MemStoreCompactionStrategy.Action action)
```
    参数:
    
    requesterVersion - The caller must hold the VersionedList of the pipeline with version taken earlier. This version must be passed as a parameter here. The flattening happens only if versions match.
  - getIndexType
```
public CompactingMemStore.IndexType getIndexType()
```
  - hasImmutableSegments
```
public boolean hasImmutableSegments()
```
  - getImmutableSegments
```
public VersionedSegmentsList getImmutableSegments()
```
  - getSmallestReadPoint
```
public long getSmallestReadPoint()
```
  - getStore
```
public HStore getStore()
```
  - getFamilyName
```
public String getFamilyName()
```
  - getScanners
```
public List<KeyValueScanner> getScanners(long readPt)
                                  throws IOException
```
    返回:
    
    scanner over the memstore. This might include scanner over the snapshot when one is present.
    
    抛出:
    
    IOException
  - createList
```
protected List<KeyValueScanner> createList(int capacity)
```
  - shouldFlushInMemory
```
protected boolean shouldFlushInMemory(MutableSegment currActive,
                                      Cell cellToAdd,
                                      MemStoreSizing memstoreSizing)
```
  - pushActiveToPipeline
```
protected void pushActiveToPipeline(MutableSegment currActive)
```
  - debug
```
public void debug()
```

类 CompactingMemStore

嵌套类概要

字段概要

从类继承的字段 org.apache.hadoop.hbase.regionserver.AbstractMemStore

构造器概要

方法概要

从类继承的方法 org.apache.hadoop.hbase.regionserver.AbstractMemStore

从类继承的方法 java.lang.Object

字段详细资料

COMPACTING_MEMSTORE_TYPE_KEY

COMPACTING_MEMSTORE_TYPE_DEFAULT

IN_MEMORY_FLUSH_THRESHOLD_FACTOR_KEY

IN_MEMORY_CONPACTION_POOL_SIZE_KEY

IN_MEMORY_CONPACTION_POOL_SIZE_DEFAULT

compactor

allowCompaction

DEEP_OVERHEAD

构造器详细资料

CompactingMemStore

方法详细资料

createMemStoreCompactor

size

preFlushSeqIDEstimation

isSloppy

snapshot

getFlushableSize

setInMemoryCompactionCompleted

setInMemoryCompactionFlag

keySize

heapSize

updateLowestUnflushedSequenceIdInWAL

startReplayingFromWAL

stopReplayingFromWAL

preUpdate

postUpdate

sizeAddedPreOperation

getSegments

setCompositeSnapshot

swapCompactedSegments

flattenOneSegment

getIndexType

hasImmutableSegments

getImmutableSegments

getSmallestReadPoint

getStore

getFamilyName

getScanners

createList

shouldFlushInMemory

pushActiveToPipeline

debug