org.apache.hadoop.hbase.regionserver

Interface MemStore

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

Modifier and Type	Method and Description
Pair<Long,Cell>	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(org.apache.hadoop.hbase.regionserver.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

Pair<Long,Cell> add(Cell cell)

Write an update

Parameters:

cell -

Returns:

approximate size of the passed KV and the newly added KV which maybe different from the passed in KV.

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(org.apache.hadoop.hbase.regionserver.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.