AbstractMemStore (Apache HBase

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

所有已实现的接口:

MemStore

直接已知子类:

CompactingMemStore, DefaultMemStore
```
@InterfaceAudience.Private
public abstract class AbstractMemStore
extends Object
implements MemStore
```
An abstract class, which implements the behaviour shared by all concrete memstore instances.

字段概要

字段
限定符和类型	字段和说明
`static long`	`DEEP_OVERHEAD`
`static long`	`FIXED_OVERHEAD`
`protected RegionServicesForStores`	`regionServices`
`protected ImmutableSegment`	`snapshot`
`protected long`	`snapshotId`

构造器概要

构造器
限定符	构造器和说明
`protected`	`AbstractMemStore(org.apache.hadoop.conf.Configuration conf, CellComparator c, RegionServicesForStores regionServices)`

方法概要

所有方法静态方法实例方法抽象方法具体方法
限定符和类型	方法和说明
`void`	`add(Cell cell, MemStoreSizing memstoreSizing)` Write an update
`void`	`add(Iterable<Cell> cells, MemStoreSizing memstoreSizing)` Write the updates
`static void`	`addToScanners(List<? extends Segment> segments, long readPt, List<KeyValueScanner> scanners)`
`protected static void`	`addToScanners(Segment segment, long readPt, List<KeyValueScanner> scanners)`
`void`	`clearSnapshot(long id)` The passed snapshot was successfully persisted; it can be let go.
`protected void`	`dump(org.slf4j.Logger log)`
`protected CellComparator`	`getComparator()`
`protected org.apache.hadoop.conf.Configuration`	`getConfiguration()`
`protected Cell`	`getLowest(Cell a, Cell b)`
`protected Cell`	`getNextRow(Cell key, NavigableSet<Cell> set)`
`protected abstract List<Segment>`	`getSegments()`
`MemStoreSize`	`getSnapshotSize()` Return the size of the snapshot(s) if any
`protected abstract long`	`heapSize()`
`protected abstract long`	`keySize()`
`protected abstract void`	`postUpdate(MutableSegment currentActive)` Issue any post update synchronization and tests
`protected abstract boolean`	`preUpdate(MutableSegment currentActive, Cell cell, MemStoreSizing memstoreSizing)` Issue any synchronization and test needed before applying the update
`protected void`	`resetActive()`
`protected abstract boolean`	`sizeAddedPreOperation()`
`long`	`timeOfOldestEdit()`
`String`	`toString()`
`abstract void`	`updateLowestUnflushedSequenceIdInWAL(boolean onlyIfMoreRecent)` Updates the wal with the lowest sequence id (oldest entry) that is still in memory
`void`	`upsert(Iterable<Cell> cells, long readpoint, MemStoreSizing memstoreSizing)` Update or insert the specified cells.

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

从接口继承的方法 org.apache.hadoop.hbase.regionserver.MemStore
getFlushableSize, getScanners, isSloppy, preFlushSeqIDEstimation, size, snapshot, startReplayingFromWAL, stopReplayingFromWAL

- 字段详细资料
  - snapshot
```
protected volatile ImmutableSegment snapshot
```
  - snapshotId
```
protected volatile long snapshotId
```
  - regionServices
```
protected RegionServicesForStores regionServices
```
  - FIXED_OVERHEAD
```
public static final long FIXED_OVERHEAD
```
  - DEEP_OVERHEAD
```
public static final long DEEP_OVERHEAD
```
- 构造器详细资料
  - AbstractMemStore
```
protected AbstractMemStore(org.apache.hadoop.conf.Configuration conf,
                           CellComparator c,
                           RegionServicesForStores regionServices)
```
- 方法详细资料
  - addToScanners
```
public static void addToScanners(List<? extends Segment> segments,
                                 long readPt,
                                 List<KeyValueScanner> scanners)
```
  - addToScanners
```
protected static void addToScanners(Segment segment,
                                    long readPt,
                                    List<KeyValueScanner> scanners)
```
  - resetActive
```
protected void resetActive()
```
  - updateLowestUnflushedSequenceIdInWAL
```
public abstract void updateLowestUnflushedSequenceIdInWAL(boolean onlyIfMoreRecent)
```
    Updates the wal with the lowest sequence id (oldest entry) that is still in memory
    
    参数:
    
    onlyIfMoreRecent - a flag that marks whether to update the sequence id no matter what or only if it is greater than the previous sequence id
  - add
```
public void add(Iterable<Cell> cells,
                MemStoreSizing memstoreSizing)
```
    从接口复制的说明: MemStore
    
    Write the updates
    
    指定者:
    
    add 在接口中 MemStore
    
    memstoreSizing - The delta in memstore size will be passed back via this. This will include both data size and heap overhead delta.
  - add
```
public void add(Cell cell,
                MemStoreSizing memstoreSizing)
```
    从接口复制的说明: MemStore
    
    Write an update
    
    指定者:
    
    add 在接口中 MemStore
    
    memstoreSizing - The delta in memstore size will be passed back via this. This will include both data size and heap overhead delta.
  - preUpdate
```
protected abstract boolean preUpdate(MutableSegment currentActive,
                                     Cell cell,
                                     MemStoreSizing memstoreSizing)
```
    Issue any synchronization and test needed before applying the update
    
    参数:
    
    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 abstract void postUpdate(MutableSegment currentActive)
```
    Issue any post update synchronization and tests
    
    参数:
    
    currentActive - updated segment
  - upsert
```
public void upsert(Iterable<Cell> cells,
                   long readpoint,
                   MemStoreSizing memstoreSizing)
```
    从接口复制的说明: MemStore
    
    Update or insert the specified cells.
    For each Cell, insert into MemStore. This will atomically upsert the value for that row/family/qualifier. If a Cell did already exist, it will then be removed.
    Currently the memstoreTS is kept at 0 so as each insert happens, it will be immediately visible. May want to change this so it is atomic across all KeyValues.
    This is called under row lock, so Get operations will still see updates atomically. Scans will only see each KeyValue update as atomic.
    
    指定者:
    
    upsert 在接口中 MemStore
    
    readpoint - readpoint below which we can safely remove duplicate Cells.
    
    memstoreSizing - The delta in memstore size will be passed back via this. This will include both data size and heap overhead delta.
  - timeOfOldestEdit
```
public long timeOfOldestEdit()
```
    指定者:
    
    timeOfOldestEdit 在接口中 MemStore
    
    返回:
    
    Oldest timestamp of all the Cells in the MemStore
  - clearSnapshot
```
public void clearSnapshot(long id)
                   throws UnexpectedStateException
```
    The passed snapshot was successfully persisted; it can be let go.
    
    指定者:
    
    clearSnapshot 在接口中 MemStore
    
    参数:
    
    id - Id of the snapshot to clean out.
    
    抛出:
    
    UnexpectedStateException
    
    另请参阅:
    
    MemStore.snapshot()
  - getSnapshotSize
```
public MemStoreSize getSnapshotSize()
```
    从接口复制的说明: MemStore
    
    Return the size of the snapshot(s) if any
    
    指定者:
    
    getSnapshotSize 在接口中 MemStore
    
    返回:
    
    size of the memstore snapshot
  - toString
```
public String toString()
```
    覆盖:
    
    toString 在类中 Object
  - getConfiguration
```
protected org.apache.hadoop.conf.Configuration getConfiguration()
```
  - dump
```
protected void dump(org.slf4j.Logger log)
```
  - getLowest
```
protected Cell getLowest(Cell a,
                         Cell b)
```
  - getNextRow
```
protected Cell getNextRow(Cell key,
                          NavigableSet<Cell> set)
```
  - sizeAddedPreOperation
```
protected abstract boolean sizeAddedPreOperation()
```
  - keySize
```
protected abstract long keySize()
```
    返回:
    
    The total size of cells in this memstore. We will not consider cells in the snapshot
  - heapSize
```
protected abstract long heapSize()
```
    返回:
    
    The total heap size of cells in this memstore. We will not consider cells in the snapshot
  - getComparator
```
protected CellComparator getComparator()
```
  - getSegments
```
protected abstract List<Segment> getSegments()
                                      throws IOException
```
    返回:
    
    an ordered list of segments from most recent to oldest in memstore
    
    抛出:
    
    IOException

类 AbstractMemStore

字段概要

构造器概要

方法概要

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

从接口继承的方法 org.apache.hadoop.hbase.regionserver.MemStore

字段详细资料

snapshot

snapshotId

regionServices

FIXED_OVERHEAD

DEEP_OVERHEAD

构造器详细资料

AbstractMemStore

方法详细资料

addToScanners

addToScanners

resetActive

updateLowestUnflushedSequenceIdInWAL

add

add

preUpdate

postUpdate

upsert

timeOfOldestEdit

clearSnapshot

getSnapshotSize

toString

getConfiguration

dump

getLowest

getNextRow

sizeAddedPreOperation

keySize

heapSize

getComparator

getSegments