A simple form of KeyValue that creates a keyvalue with only the key part of the byte[] Mainly used in places where we need to compare two cells.

This can be used when a Cell has to change with addition/removal of one or more tags.

Create a Cell with specific row and value.

Marked as audience Private as of 1.2.0.

Try to return a Cell that falls between left and right but that is shorter; i.e.

copy key and value

Create a new KeyValue by copying existing cell and adding new tags

Compares the Key of a cell -- with fields being more significant in this order: rowkey, colfam/qual, timestamp, type, mvcc

Compare cells.

Compares the only the user specified portion of a Key.

Compares cell's timestamps in DESCENDING order.

The position will be set to the beginning of the new ByteBuffer

copyTo

copy key only

Append single byte 0x00 to the end of the input row key

Creates a keyValue for the specified keyvalue larger than or equal to all other possible KeyValues that have the same row, family, qualifer.

Deprecated. 

equals

This is an estimate of the heap space occupied by a cell.

Deprecated. 

Try to return a Cell that falls between left and right but that is shorter; i.e.

misc

Returns a hash code that is always the same for two Cells having a matching equals(..) result.

Returns number of bytes this cell's key part would have been used if serialized as in KeyValue.

Compares the row and column of two keyvalues for equality

Sets the given seqId to the cell.

Sets the given timestamp to the cell.

Sets the given timestamp to the cell iff current timestamp is HConstants.LATEST_TIMESTAMP.

Writes the Cell's key part as it would have serialized in a KeyValue.

Checks whether KeyValues from kvCollection2 are contained in kvCollection1.

Deprecated. 

The last cell from a not full Row which is added to cache

The Cell for the most recent timestamp for a given column.

Return the array of Cells backing this Result instance.

Creates an empty list if one doesn't exist for the given column family or else it returns the associated list of Cell objects.

Method for retrieving the put's familyMap

Add the specified KeyValue to this operation.

Advanced use only.

Searches for the latest value for the specified column.

Compare two Cells considering reversed scanner.

Method for setting the put's familyMap

currently must do deep copy into new array

Deprecated. 

Extends PtCell and manipulates its protected fields.

As the PrefixTreeArrayScanner moves through the tree bytes, it changes the values in the fields of this class so that Cell logic can be applied, but without allocating new memory for every Cell iterated through.

Compare only the bytes within the window of the current token

fill in family/qualifier/ts/type/value

Identical workflow as positionAtOrBefore, but split them to avoid having ~10 extra if-statements.

Add a Cell to the output stream but repeat the previous row.

Same as positionAt(..), but go to the extra effort of finding the next key if there's no exact match.

Note: Added for backwards compatibility with KeyValueScanner.reseek(org.apache.hadoop.hbase.Cell)

Same as seekForwardTo(..), but go to the extra effort of finding the next key if there's no exact match.

Called after a new cell has been created during an increment operation, but before it is committed to the WAL or memstore.

Called before the server updates the timestamp for version delete with latest timestamp.

When filtering a given Cell in FilterList.filterKeyValue(Cell), this stores the transformed Cell to be returned by FilterList.transformCell(Cell).

If the filter returns the match code SEEK_NEXT_USING_HINT, then it should also tell which is the next key it must seek to.

By default no transformation takes place Give the filter a chance to transform the passed KeyValue.

Give the filter a chance to transform the passed KeyValue.

If the filter returns the match code SEEK_NEXT_USING_HINT, then it should also tell which is the next key it must seek to.

By default no transformation takes place Give the filter a chance to transform the passed KeyValue.

Give the filter a chance to transform the passed KeyValue.

Filters that never filter by modifying the returned List of Cells can inherit this implementation that does nothing.

Encodes a KeyValue.

The Cell previously appended.

The first key in the next block following this one in the HFile.

Add key/value to file.

Performs a binary search over a non-root level index block.

Within a loaded block, seek looking for the last key that is smaller than (or equal to?) the key we are interested in.

Encodes a KeyValue.

Return the BlockWithScanInfo which contains the DataBlock with other scan info such as nextIndexedKey.

Finds the root-level index block containing the given key.

Return the data block which contains this key.

Deprecated. 

Returns the next Cell in the current row or null iff none remain.

Compare families, qualifiers, and timestamps of the given Cells.

A mocked list implementation - discards all updates.

Find the key that matches row exactly, or the one that immediately precedes it.

Return the next Cell in this scanner, iterating the scanner

Do a get based on the get parameter.

Do a specific Get on passed columnFamily and column qualifiers from incrementCoordinates only.

Write an update

Add the specified KeyValue to the list of deletes to check against for this row operation.

Seek scanner to the given key first.

Check whether scan as expected order

Compares two KeyValue

Write a delete

Get cell length after serialized in KeyValue

Return HStore instance.

Internal version of add() that doesn't clone Cells with the allocator, and doesn't take the lock.

Check if the specified cell buffer has been deleted by a previously seen delete.

Check if the specified KeyValue buffer has been deleted by a previously seen delete.

Determines if the caller should do one of several things: - seek/skip to the next row (MatchCode.SEEK_NEXT_ROW) - seek/skip to the next column (MatchCode.SEEK_NEXT_COL) - include the current KeyValue (MatchCode.INCLUDE) - ignore the current KeyValue (MatchCode.SKIP) - got to the next row (MatchCode.DONE)

Seek storefiles in parallel to optimize IO latency as much as possible

Similar to KeyValueScanner.seek(org.apache.hadoop.hbase.Cell) (or KeyValueScanner.reseek(org.apache.hadoop.hbase.Cell) if forward is true) but only does a seek operation after checking that it is really necessary for the row/column combination specified by the kv parameter.

Pretend we have done a seek but don't do it yet, if possible.

Move forward on the sub-lists set previously by seek.

This function is identical to the KeyValueHeap.seek(Cell) function except that scanner.seek(seekKey) is changed to scanner.reseek(seekKey).

Remove n key from the memstore.

Removes a Cell from the memstore.

Set the scanner at the seek key.

Seeks all scanners at or below the specified seek key.

Do a backwardSeek in a reversed StoreScanner(scan backward)

(Re)initialize the iterators after a seek or a reseek.

Seek the scanner at the first Cell of the row which is the previous row of specified key

Record the earlest Put timestamp.

Append the given map of family->edits to a WALEdit data structure.

Apply increments to a column family.

Check the collection of families for valid timestamps

This is used only by unit tests.

Do a specific Get on passed columnFamily and column qualifiers from incrementCoordinates only.

Grab the next row's worth of values.

Gets the next row of keys from the top-most scanner.

Grab the next row's worth of values.

Fetches records with currentRow into results list, until next row, batchLimit (if not -1) is reached, or remainingResultSize (if not -1) is reaced

Update counters for number of puts without wal and the size of possible data loss.

Possibly rewrite incoming cell tags.