MemStore (Apache HBase 1.2.12 API)

All Superinterfaces:

HeapSize

All Known Implementing Classes:

DefaultMemStore
```
@InterfaceAudience.Private
public interface MemStore
extends HeapSize
```
The MemStore holds in-memory modifications to the Store. Modifications are Cells.
The MemStore functions should not be called in parallel. Callers should hold write and read locks. This is done in HStore.

Method Summary

Methods
Modifier and Type	Method and Description
`long`	`add(Cell cell)` Write an update
`void`	`clearSnapshot(long id)` Clears the current snapshot of the Memstore.
`long`	`delete(Cell deleteCell)` Write a delete
`long`	`getFlushableSize()` On flush, how much memory we will clear.
`void`	`getRowKeyAtOrBefore(GetClosestRowBeforeTracker state)` Find the key that matches row exactly, or the one that immediately precedes it.
`List<KeyValueScanner>`	`getScanners(long readPt)`
`long`	`getSnapshotSize()` Return the size of the snapshot(s) if any
`void`	`rollback(Cell cell)` Remove n key from the memstore.
`long`	`size()`
`MemStoreSnapshot`	`snapshot()` Creates a snapshot of the current memstore.
`long`	`timeOfOldestEdit()`
`long`	`updateColumnValue(byte[] row, byte[] family, byte[] qualifier, long newValue, long now)` Given the specs of a column, update it, first by inserting a new record, then removing the old one.
`long`	`upsert(Iterable<Cell> cells, long readpoint)` Update or insert the specified cells.

Methods inherited from interface org.apache.hadoop.hbase.io.HeapSize
heapSize

- Method Detail
  - snapshot
```
MemStoreSnapshot snapshot()
```
    Creates a snapshot of the current memstore. Snapshot must be cleared by call to clearSnapshot(long).
    
    Returns:
    MemStoreSnapshot
  - clearSnapshot
```
void clearSnapshot(long id)
                   throws UnexpectedStateException
```
    Clears the current snapshot of the Memstore.
    
    Parameters:
    id -
    
    Throws:
    
    UnexpectedStateException
    See Also:
    snapshot()
  - getFlushableSize
```
long getFlushableSize()
```
    On flush, how much memory we will clear. 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.
    
    Returns:
    size of data that is going to be flushed
  - getSnapshotSize
```
long getSnapshotSize()
```
    Return the size of the snapshot(s) if any
    
    Returns:
    size of the memstore snapshot
  - add
```
long add(Cell cell)
```
    Write an update
    
    Parameters:
    cell -
    
    Returns:
    approximate size of the passed cell.
  - timeOfOldestEdit
```
long timeOfOldestEdit()
```
    Returns:
    Oldest timestamp of all the Cells in the MemStore
  - rollback
```
void rollback(Cell cell)
```
    Remove n key from the memstore. Only kvs that have the same key and the same memstoreTS are removed. It is ok to not update timeRangeTracker in this call.
    
    Parameters:
    cell -
  - delete
```
long delete(Cell deleteCell)
```
    Write a delete
    
    Parameters:
    deleteCell -
    
    Returns:
    approximate size of the passed key and value.
  - getRowKeyAtOrBefore
```
void getRowKeyAtOrBefore(GetClosestRowBeforeTracker state)
```
    Find the key that matches row exactly, or the one that immediately precedes it. The target row key is set in state.
    
    Parameters:
    state - column/delete tracking state
  - updateColumnValue
```
long updateColumnValue(byte[] row,
                     byte[] family,
                     byte[] qualifier,
                     long newValue,
                     long now)
```
    Given the specs of a column, update it, first by inserting a new record, then removing the old one. Since there is only 1 KeyValue involved, the memstoreTS will be set to 0, thus ensuring that they instantly appear to anyone. The underlying store will ensure that the insert/delete each are atomic. A scanner/reader will either get the new value, or the old value and all readers will eventually only see the new value after the old was removed.
    
    Parameters:
    row -
    family -
    qualifier -
    newValue -
    now -
    
    Returns:
    Timestamp
  - upsert
```
long upsert(Iterable<Cell> cells,
          long readpoint)
```
    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.
    
    Parameters:
    cells -
    readpoint - readpoint below which we can safely remove duplicate Cells.
    
    Returns:
    change in memstore size
  - getScanners
```
List<KeyValueScanner> getScanners(long readPt)
```
    Returns:
    scanner over the memstore. This might include scanner over the snapshot when one is present.
  - size
```
long size()
```
    Returns:
    Total memory occupied by this MemStore.

Interface MemStore

Method Summary

Methods inherited from interface org.apache.hadoop.hbase.io.HeapSize

Method Detail

snapshot

clearSnapshot

getFlushableSize

getSnapshotSize

add

timeOfOldestEdit

rollback

delete

getRowKeyAtOrBefore

updateColumnValue

upsert

getScanners

size