CellUtil (Apache HBase - Common 2.0.0-alpha2 API)

java.lang.Object
- org.apache.hadoop.hbase.CellUtil

```
@InterfaceAudience.Public
public final class CellUtil
extends Object
```
Utility methods helpful slinging Cell instances. Some methods below are for internal use only and are marked InterfaceAudience.Private at the method level.

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static byte[]`	`cloneFamily(Cell cell)`
`static byte[]`	`cloneQualifier(Cell cell)`
`static byte[]`	`cloneRow(Cell cell)` get individual arrays for tests
`static byte[]`	`cloneTags(Cell cell)`
`static byte[]`	`cloneValue(Cell cell)`
`static void`	`compressFamily(OutputStream out, Cell cell, Dictionary dict)`
`static void`	`compressQualifier(OutputStream out, Cell cell, Dictionary dict)`
`static void`	`compressRow(OutputStream out, Cell cell, Dictionary dict)`
`static void`	`compressTags(OutputStream out, Cell cell, TagCompressionContext tagCompressionContext)` Compresses the tags to the given outputstream using the TagcompressionContext
`static int`	`copyFamilyTo(Cell cell, byte[] destination, int destinationOffset)`
`static int`	`copyFamilyTo(Cell cell, ByteBuffer destination, int destinationOffset)`
`static int`	`copyQualifierTo(Cell cell, byte[] destination, int destinationOffset)`
`static int`	`copyQualifierTo(Cell cell, ByteBuffer destination, int destinationOffset)`
`static byte[]`	`copyRow(Cell cell)` Copies the row to a new byte[]
`static int`	`copyRowTo(Cell cell, byte[] destination, int destinationOffset)` copyTo
`static int`	`copyRowTo(Cell cell, ByteBuffer destination, int destinationOffset)`
`static int`	`copyTagTo(Cell cell, byte[] destination, int destinationOffset)` Copies the tags info into the tag portion of the cell
`static int`	`copyTagTo(Cell cell, ByteBuffer destination, int destinationOffset)`
`static int`	`copyValueTo(Cell cell, byte[] destination, int destinationOffset)`
`static int`	`copyValueTo(Cell cell, ByteBuffer destination, int destinationOffset)`
`static Cell`	`createCell(byte[] row)` Create a Cell with specific row.
`static Cell`	`createCell(byte[] row, byte[] value)` Create a Cell with specific row and value.
`static Cell`	`createCell(byte[] row, byte[] family, byte[] qualifier)` Create a Cell with specific row.
`static Cell`	`createCell(byte[] row, byte[] family, byte[] qualifier, long timestamp, byte type, byte[] value)`
`static Cell`	`createCell(byte[] row, byte[] family, byte[] qualifier, long timestamp, byte type, byte[] value, byte[] tags, long memstoreTS)` Marked as audience Private as of 1.2.0.
`static Cell`	`createCell(byte[] row, byte[] family, byte[] qualifier, long timestamp, byte type, byte[] value, long memstoreTS)` Marked as audience Private as of 1.2.0.
`static Cell`	`createCell(byte[] row, byte[] family, byte[] qualifier, long timestamp, KeyValue.Type type, byte[] value, byte[] tags)` Marked as audience Private as of 1.2.0.
`static Cell`	`createCell(byte[] rowArray, int rowOffset, int rowLength, byte[] familyArray, int familyOffset, int familyLength, byte[] qualifierArray, int qualifierOffset, int qualifierLength)`
`static Cell`	`createCell(Cell cell, byte[] tags)`
`static Cell`	`createCell(Cell cell, byte[] value, byte[] tags)`
`static Cell`	`createCell(Cell cell, List<Tag> tags)`
`static CellScanner`	`createCellScanner(Cell[] cellArray)`
`static CellScanner`	`createCellScanner(Iterable<Cell> cellIterable)`
`static CellScanner`	`createCellScanner(Iterator<Cell> cells)`
`static CellScanner`	`createCellScanner(List<? extends CellScannable> cellScannerables)`
`static CellScanner`	`createCellScanner(NavigableMap<byte[],List<Cell>> map)` Flatten the map of cells out under the CellScanner
`static Cell`	`createFirstDeleteFamilyCellOnRow(byte[] row, byte[] fam)` Create a Delete Family Cell for the specified row and family that would be smaller than all other possible Delete Family KeyValues that have the same row and family.
`static Cell`	`createFirstOnNextRow(Cell cell)` Create a Cell that is smaller than all other possible Cells for the given Cell row's next row.
`static Cell`	`createFirstOnRow(byte[] row)`
`static Cell`	`createFirstOnRow(byte[] row, byte[] family, byte[] col)`
`static Cell`	`createFirstOnRow(byte[] row, int roffset, short rlength)`
`static Cell`	`createFirstOnRow(byte[] row, int roffset, short rlength, byte[] family, int foffset, byte flength, byte[] col, int coffset, int clength)`
`static Cell`	`createFirstOnRow(Cell cell)` Create a Cell that is smaller than all other possible Cells for the given Cell's row.
`static Cell`	`createFirstOnRowCol(Cell cell)` Create a Cell that is smaller than all other possible Cells for the given Cell's row.
`static Cell`	`createFirstOnRowCol(Cell cell, byte[] qArray, int qoffest, int qlength)` Create a Cell that is smaller than all other possible Cells for the given Cell's rk:cf and passed qualifier.
`static Cell`	`createFirstOnRowColTS(Cell cell, long ts)` Creates the first cell with the row/family/qualifier of this cell and the given timestamp.
`static Cell`	`createFirstOnRowFamily(Cell cell, byte[] fArray, int foff, int flen)`
`static Cell`	`createLastOnRow(byte[] row)`
`static Cell`	`createLastOnRow(Cell cell)` Create a Cell that is larger than all other possible Cells for the given Cell's row.
`static Cell`	`createLastOnRowCol(Cell cell)` Create a Cell that is larger than all other possible Cells for the given Cell's rk:cf:q.
`static boolean`	`equals(Cell a, Cell b)` equals
`static boolean`	`equalsIgnoreMvccVersion(Cell a, Cell b)` special case for Cell.equals
`static long`	`estimatedHeapSizeOf(Cell cell)` This is an estimate of the heap space occupied by a cell.
`static int`	`estimatedSerializedSizeOf(Cell cell)` Estimate based on keyvalue's serialization format.
`static int`	`estimatedSerializedSizeOfKey(Cell cell)` Calculates the serialized key size.
`static ByteRange`	`fillFamilyRange(Cell cell, ByteRange range)`
`static ByteRange`	`fillQualifierRange(Cell cell, ByteRange range)`
`static ByteRange`	`fillRowRange(Cell cell, ByteRange range)` ByteRange
`static ByteRange`	`fillTagRange(Cell cell, ByteRange range)`
`static ByteRange`	`fillValueRange(Cell cell, ByteRange range)`
`static int`	`findCommonPrefixInFlatKey(Cell c1, Cell c2, boolean bypassFamilyCheck, boolean withTsType)` Find length of common prefix in keys of the cells, considering key as byte[] if serialized in `KeyValue`.
`static String`	`getCellKeyAsString(Cell cell)`
`static byte[]`	`getCellKeySerializedAsKeyValueKey(Cell cell)` This method exists just to encapsulate how we serialize keys.
`static ByteBuffer`	`getQualifierBufferShallowCopy(Cell cell)` Deprecated. As of release 2.0.0, this will be removed in HBase 3.0.0.
`static byte`	`getQualifierByte(Cell cell, int index)`
`static int`	`getRowAsInt(Cell cell)` Converts the rowkey bytes of the given cell into an int value
`static byte`	`getRowByte(Cell cell, int index)` misc
`static Tag`	`getTag(Cell cell, byte type)` Retrieve Cell's first tag, matching the passed in type
`static byte[]`	`getTagArray(Cell cell)` Returns tag value in a new byte array.
`static List<Tag>`	`getTags(Cell cell)`
`static BigDecimal`	`getValueAsBigDecimal(Cell cell)` Converts the value bytes of the given cell into a BigDecimal
`static double`	`getValueAsDouble(Cell cell)` Converts the value bytes of the given cell into a double value
`static int`	`getValueAsInt(Cell cell)` Converts the value bytes of the given cell into a int value
`static long`	`getValueAsLong(Cell cell)` Converts the value bytes of the given cell into a long value
`static ByteBuffer`	`getValueBufferShallowCopy(Cell cell)`
`static boolean`	`isDelete(byte type)`
`static boolean`	`isDelete(Cell cell)`
`static boolean`	`isDeleteColumnOrFamily(Cell cell)`
`static boolean`	`isDeleteColumns(Cell cell)`
`static boolean`	`isDeleteColumnVersion(Cell cell)`
`static boolean`	`isDeleteFamily(Cell cell)`
`static boolean`	`isDeleteFamilyVersion(Cell cell)`
`static boolean`	`isDeleteType(Cell cell)`
`static boolean`	`matchingColumn(Cell left, byte[] fam, byte[] qual)`
`static boolean`	`matchingColumn(Cell left, byte[] fam, int foffset, int flength, byte[] qual, int qoffset, int qlength)`
`static boolean`	`matchingColumn(Cell left, Cell right)`
`static boolean`	`matchingFamily(Cell left, byte[] buf)`
`static boolean`	`matchingFamily(Cell left, byte[] buf, int offset, int length)`
`static boolean`	`matchingFamily(Cell left, Cell right)`
`static boolean`	`matchingQualifier(Cell left, byte[] buf)` Finds if the qualifier part of the cell and the KV serialized byte[] are equal
`static boolean`	`matchingQualifier(Cell left, byte[] buf, int offset, int length)` Finds if the qualifier part of the cell and the KV serialized byte[] are equal
`static boolean`	`matchingQualifier(Cell left, Cell right)`
`static boolean`	`matchingRow(Cell left, byte[] buf)`
`static boolean`	`matchingRow(Cell left, byte[] buf, int offset, int length)`
`static boolean`	`matchingRow(Cell left, Cell right)` Deprecated. As of release 2.0.0, this will be removed in HBase 3.0.0. Instead use `matchingRows(Cell, Cell)`
`static boolean`	`matchingRowColumn(Cell left, Cell right)` Compares the row and column of two keyvalues for equality
`static boolean`	`matchingRows(Cell left, Cell right)` Compares the row of two keyvalues for equality
`static boolean`	`matchingTimestamp(Cell a, Cell b)`
`static boolean`	`matchingType(Cell a, Cell b)`
`static boolean`	`matchingValue(Cell left, byte[] buf)`
`static boolean`	`matchingValue(Cell left, Cell right)`
`static boolean`	`matchingValue(Cell left, Cell right, int lvlength, int rvlength)`
`static boolean`	`overlappingKeys(byte[] start1, byte[] end1, byte[] start2, byte[] end2)` Returns true if the first range start1...end1 overlaps with the second range start2...end2, assuming the byte arrays represent row keys
`static void`	`setSequenceId(Cell cell, long seqId)` Sets the given seqId to the cell.
`static void`	`setTimestamp(Cell cell, byte[] ts, int tsOffset)` Sets the given timestamp to the cell.
`static void`	`setTimestamp(Cell cell, long ts)` Sets the given timestamp to the cell.
`static Iterator<Tag>`	`tagsIterator(byte[] tags, int offset, int length)` Deprecated. As of 2.0.0 and will be removed in 3.0.0 Instead use `tagsIterator(Cell)`
`static Iterator<Tag>`	`tagsIterator(Cell cell)` Util method to iterate through the tags in the given cell.
`static String`	`toString(Cell cell, boolean verbose)` Returns a string representation of the cell
`static boolean`	`updateLatestStamp(Cell cell, byte[] ts, int tsOffset)` Sets the given timestamp to the cell iff current timestamp is `HConstants.LATEST_TIMESTAMP`.
`static boolean`	`updateLatestStamp(Cell cell, long ts)` Sets the given timestamp to the cell iff current timestamp is `HConstants.LATEST_TIMESTAMP`.
`static void`	`writeFamily(OutputStream out, Cell cell, byte flength)` Writes the family from the given cell to the output stream
`static void`	`writeFlatKey(Cell cell, DataOutputStream out)` Writes the Cell's key part as it would have serialized in a KeyValue.
`static int`	`writeFlatKey(Cell cell, OutputStream out)`
`static void`	`writeQualifier(OutputStream out, Cell cell, int qlength)` Writes the qualifier from the given cell to the output stream
`static void`	`writeQualifierSkippingBytes(DataOutputStream out, Cell cell, int qlength, int commonPrefix)` Writes the qualifier from the given cell to the output stream excluding the common prefix
`static void`	`writeRow(OutputStream out, Cell cell, short rlength)` Writes the row from the given cell to the output stream
`static void`	`writeRowKeyExcludingCommon(Cell cell, short rLen, int commonPrefix, DataOutputStream out)` Write rowkey excluding the common part.
`static void`	`writeRowSkippingBytes(DataOutputStream out, Cell cell, short rlength, int commonPrefix)` Writes the row from the given cell to the output stream excluding the common prefix
`static void`	`writeTags(OutputStream out, Cell cell, int tagsLength)` Writes the tag from the given cell to the output stream
`static void`	`writeValue(OutputStream out, Cell cell, int vlength)` Writes the value from the given cell to the output stream

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

fillRowRange

public static ByteRange fillRowRange(Cell cell,
                                     ByteRange range)

ByteRange

fillFamilyRange

public static ByteRange fillFamilyRange(Cell cell,
                                        ByteRange range)

fillQualifierRange

public static ByteRange fillQualifierRange(Cell cell,
                                           ByteRange range)

fillValueRange

public static ByteRange fillValueRange(Cell cell,
                                       ByteRange range)

fillTagRange

public static ByteRange fillTagRange(Cell cell,
                                     ByteRange range)

cloneRow

public static byte[] cloneRow(Cell cell)

get individual arrays for tests

cloneFamily

public static byte[] cloneFamily(Cell cell)

cloneQualifier

public static byte[] cloneQualifier(Cell cell)

cloneValue

public static byte[] cloneValue(Cell cell)

cloneTags

public static byte[] cloneTags(Cell cell)

getTagArray
```
public static byte[] getTagArray(Cell cell)
```
Returns tag value in a new byte array. If server-side, use Tag.getValueArray() with appropriate Tag.getValueOffset() and Tag.getValueLength() instead to save on allocations.

Parameters:

cell -

Returns:

tag value in a new byte array.

copyRowTo

public static int copyRowTo(Cell cell,
                            byte[] destination,
                            int destinationOffset)

copyTo

copyRowTo

public static int copyRowTo(Cell cell,
                            ByteBuffer destination,
                            int destinationOffset)

copyRow
```
public static byte[] copyRow(Cell cell)
```
Copies the row to a new byte[]

Parameters:

cell - the cell from which row has to copied

Returns:

the byte[] containing the row

copyFamilyTo

public static int copyFamilyTo(Cell cell,
                               byte[] destination,
                               int destinationOffset)

copyFamilyTo

public static int copyFamilyTo(Cell cell,
                               ByteBuffer destination,
                               int destinationOffset)

copyQualifierTo

public static int copyQualifierTo(Cell cell,
                                  byte[] destination,
                                  int destinationOffset)

copyQualifierTo

public static int copyQualifierTo(Cell cell,
                                  ByteBuffer destination,
                                  int destinationOffset)

copyValueTo

public static int copyValueTo(Cell cell,
                              byte[] destination,
                              int destinationOffset)

copyValueTo

public static int copyValueTo(Cell cell,
                              ByteBuffer destination,
                              int destinationOffset)

copyTagTo

public static int copyTagTo(Cell cell,
                            byte[] destination,
                            int destinationOffset)

Copies the tags info into the tag portion of the cell

Parameters:: cell -; destination -; destinationOffset -
Returns:: position after tags

copyTagTo

public static int copyTagTo(Cell cell,
                            ByteBuffer destination,
                            int destinationOffset)

getRowByte

@InterfaceAudience.Private
public static byte getRowByte(Cell cell,
                                                         int index)

misc

getQualifierByte

@InterfaceAudience.Private
public static byte getQualifierByte(Cell cell,
                                                               int index)

getValueBufferShallowCopy

public static ByteBuffer getValueBufferShallowCopy(Cell cell)

getQualifierBufferShallowCopy
```
@Deprecated
public static ByteBuffer getQualifierBufferShallowCopy(Cell cell)
```
Deprecated. As of release 2.0.0, this will be removed in HBase 3.0.0.

Parameters:

cell -

Returns:

cell's qualifier wrapped into a ByteBuffer.

createCell

public static Cell createCell(byte[] row,
                              byte[] family,
                              byte[] qualifier,
                              long timestamp,
                              byte type,
                              byte[] value)

createCell

public static Cell createCell(byte[] rowArray,
                              int rowOffset,
                              int rowLength,
                              byte[] familyArray,
                              int familyOffset,
                              int familyLength,
                              byte[] qualifierArray,
                              int qualifierOffset,
                              int qualifierLength)

createCell

@InterfaceAudience.Private
public static Cell createCell(byte[] row,
                                                         byte[] family,
                                                         byte[] qualifier,
                                                         long timestamp,
                                                         byte type,
                                                         byte[] value,
                                                         long memstoreTS)

Marked as audience Private as of 1.2.0. Creating a Cell with a memstoreTS/mvcc is an internal implementation detail not for public use.

createCell

@InterfaceAudience.Private
public static Cell createCell(byte[] row,
                                                         byte[] family,
                                                         byte[] qualifier,
                                                         long timestamp,
                                                         byte type,
                                                         byte[] value,
                                                         byte[] tags,
                                                         long memstoreTS)

Marked as audience Private as of 1.2.0. Creating a Cell with tags and a memstoreTS/mvcc is an internal implementation detail not for public use.

createCell

@InterfaceAudience.Private
public static Cell createCell(byte[] row,
                                                         byte[] family,
                                                         byte[] qualifier,
                                                         long timestamp,
                                                         KeyValue.Type type,
                                                         byte[] value,
                                                         byte[] tags)

Marked as audience Private as of 1.2.0. Creating a Cell with tags is an internal implementation detail not for public use.

createCell
```
public static Cell createCell(byte[] row)
```
Create a Cell with specific row. Other fields defaulted.

Parameters:

row -

Returns:

Cell with passed row but all other fields are arbitrary

createCell
```
public static Cell createCell(byte[] row,
                              byte[] value)
```
Create a Cell with specific row and value. Other fields are defaulted.

Parameters:

row -

value -

Returns:

Cell with passed row and value but all other fields are arbitrary

createCell
```
public static Cell createCell(byte[] row,
                              byte[] family,
                              byte[] qualifier)
```
Create a Cell with specific row. Other fields defaulted.

Parameters:

row -

family -

qualifier -

Returns:

Cell with passed row but all other fields are arbitrary

createCell

public static Cell createCell(Cell cell,
                              List<Tag> tags)

Returns:: A new cell which is having the extra tags also added to it.

createCell

public static Cell createCell(Cell cell,
                              byte[] tags)

Returns:: A new cell which is having the extra tags also added to it.

createCell

public static Cell createCell(Cell cell,
                              byte[] value,
                              byte[] tags)

createCellScanner

public static CellScanner createCellScanner(List<? extends CellScannable> cellScannerables)

Parameters:: cellScannerables -
Returns:: CellScanner interface over cellIterables

createCellScanner
```
public static CellScanner createCellScanner(Iterable<Cell> cellIterable)
```
Parameters:

cellIterable -

Returns:

CellScanner interface over cellIterable

createCellScanner
```
public static CellScanner createCellScanner(Iterator<Cell> cells)
```
Parameters:

cells -

Returns:

CellScanner interface over cellIterable or null if cells is null

createCellScanner
```
public static CellScanner createCellScanner(Cell[] cellArray)
```
Parameters:

cellArray -

Returns:

CellScanner interface over cellArray

createCellScanner
```
public static CellScanner createCellScanner(NavigableMap<byte[],List<Cell>> map)
```
Flatten the map of cells out under the CellScanner

Parameters:

map - Map of Cell Lists; for example, the map of families to Cells that is used inside Put, etc., keeping Cells organized by family.

Returns:

CellScanner interface over cellIterable

matchingRow
```
@Deprecated
public static boolean matchingRow(Cell left,
                                              Cell right)
```
Deprecated. As of release 2.0.0, this will be removed in HBase 3.0.0. Instead use matchingRows(Cell, Cell)

Parameters:

left -

right -

Returns:

True if the rows in left and right Cells match

matchingRow

public static boolean matchingRow(Cell left,
                                  byte[] buf)

matchingRow

public static boolean matchingRow(Cell left,
                                  byte[] buf,
                                  int offset,
                                  int length)

matchingFamily

public static boolean matchingFamily(Cell left,
                                     Cell right)

matchingFamily

public static boolean matchingFamily(Cell left,
                                     byte[] buf)

matchingFamily

public static boolean matchingFamily(Cell left,
                                     byte[] buf,
                                     int offset,
                                     int length)

matchingQualifier

public static boolean matchingQualifier(Cell left,
                                        Cell right)

matchingQualifier
```
public static boolean matchingQualifier(Cell left,
                                        byte[] buf)
```
Finds if the qualifier part of the cell and the KV serialized byte[] are equal

Parameters:

left -

buf - the serialized keyvalue format byte[]

Returns:

true if the qualifier matches, false otherwise

matchingQualifier
```
public static boolean matchingQualifier(Cell left,
                                        byte[] buf,
                                        int offset,
                                        int length)
```
Finds if the qualifier part of the cell and the KV serialized byte[] are equal

Parameters:

left -

buf - the serialized keyvalue format byte[]

offset - the offset of the qualifier in the byte[]

length - the length of the qualifier in the byte[]

Returns:

true if the qualifier matches, false otherwise

matchingColumn

public static boolean matchingColumn(Cell left,
                                     byte[] fam,
                                     byte[] qual)

matchingColumn

public static boolean matchingColumn(Cell left,
                                     byte[] fam,
                                     int foffset,
                                     int flength,
                                     byte[] qual,
                                     int qoffset,
                                     int qlength)

matchingColumn

public static boolean matchingColumn(Cell left,
                                     Cell right)

matchingValue

public static boolean matchingValue(Cell left,
                                    Cell right)

matchingValue

public static boolean matchingValue(Cell left,
                                    Cell right,
                                    int lvlength,
                                    int rvlength)

matchingValue

public static boolean matchingValue(Cell left,
                                    byte[] buf)

isDelete
```
public static boolean isDelete(Cell cell)
```
Returns:

True if a delete type, a KeyValue.Type.Delete or a {KeyValue.Type#DeleteFamily} or a KeyValue.Type.DeleteColumn KeyValue type.

isDelete
```
public static boolean isDelete(byte type)
```
Returns:

True if a delete type, a KeyValue.Type.Delete or a {KeyValue.Type#DeleteFamily} or a KeyValue.Type.DeleteColumn KeyValue type.

isDeleteType
```
public static boolean isDeleteType(Cell cell)
```
Returns:

True if this cell is a KeyValue.Type.Delete type.

isDeleteFamily

public static boolean isDeleteFamily(Cell cell)

isDeleteFamilyVersion

public static boolean isDeleteFamilyVersion(Cell cell)

isDeleteColumns

public static boolean isDeleteColumns(Cell cell)

isDeleteColumnVersion

public static boolean isDeleteColumnVersion(Cell cell)

isDeleteColumnOrFamily
```
public static boolean isDeleteColumnOrFamily(Cell cell)
```
Returns:

True if this cell is a delete family or column type.

estimatedSerializedSizeOf
```
public static int estimatedSerializedSizeOf(Cell cell)
```
Estimate based on keyvalue's serialization format.

Parameters:

cell -

Returns:

Estimate of the cell size in bytes.

estimatedSerializedSizeOfKey
```
public static int estimatedSerializedSizeOfKey(Cell cell)
```
Calculates the serialized key size. We always serialize in the KeyValue's serialization format.

Parameters:

cell - the cell for which the key size has to be calculated.

Returns:

the key size

estimatedHeapSizeOf
```
public static long estimatedHeapSizeOf(Cell cell)
```
This is an estimate of the heap space occupied by a cell. When the cell is of type HeapSize we call HeapSize.heapSize() so cell can give a correct value. In other cases we just consider the bytes occupied by the cell components ie. row, CF, qualifier, timestamp, type, value and tags.

Parameters:

cell -

Returns:

estimate of the heap space

tagsIterator
```
@Deprecated
public static Iterator<Tag> tagsIterator(byte[] tags,
                                                     int offset,
                                                     int length)
```
Deprecated. As of 2.0.0 and will be removed in 3.0.0 Instead use tagsIterator(Cell)

Util method to iterate through the tags

Parameters:

tags -

offset -

length -

Returns:

iterator for the tags

tagsIterator
```
public static Iterator<Tag> tagsIterator(Cell cell)
```
Util method to iterate through the tags in the given cell.

Parameters:

cell - The Cell over which tags iterator is needed.

Returns:

iterator for the tags

getTags
```
public static List<Tag> getTags(Cell cell)
```
Parameters:

cell - The Cell

Returns:

Tags in the given Cell as a List

getTag
```
public static Tag getTag(Cell cell,
                         byte type)
```
Retrieve Cell's first tag, matching the passed in type

Parameters:

cell - The Cell

type - Type of the Tag to retrieve

Returns:

null if there is no tag of the passed in tag type

overlappingKeys

public static boolean overlappingKeys(byte[] start1,
                                      byte[] end1,
                                      byte[] start2,
                                      byte[] end2)

Returns true if the first range start1...end1 overlaps with the second range start2...end2, assuming the byte arrays represent row keys

setSequenceId
```
@InterfaceAudience.Private
public static void setSequenceId(Cell cell,
                                                            long seqId)
                                                     throws IOException
```
Sets the given seqId to the cell. Marked as audience Private as of 1.2.0. Setting a Cell sequenceid is an internal implementation detail not for general public use.

Parameters:

cell -

seqId -

Throws:

IOException - when the passed cell is not of type SettableSequenceId

setTimestamp
```
public static void setTimestamp(Cell cell,
                                long ts)
                         throws IOException
```
Sets the given timestamp to the cell.

Parameters:

cell -

ts -

Throws:

IOException - when the passed cell is not of type SettableTimestamp

setTimestamp
```
public static void setTimestamp(Cell cell,
                                byte[] ts,
                                int tsOffset)
                         throws IOException
```
Sets the given timestamp to the cell.

Parameters:

cell -

ts - buffer containing the timestamp value

tsOffset - offset to the new timestamp

Throws:

IOException - when the passed cell is not of type SettableTimestamp

updateLatestStamp
```
public static boolean updateLatestStamp(Cell cell,
                                        long ts)
                                 throws IOException
```
Sets the given timestamp to the cell iff current timestamp is HConstants.LATEST_TIMESTAMP.

Parameters:

cell -

ts -

Returns:

True if cell timestamp is modified.

Throws:

IOException - when the passed cell is not of type SettableTimestamp

updateLatestStamp
```
public static boolean updateLatestStamp(Cell cell,
                                        byte[] ts,
                                        int tsOffset)
                                 throws IOException
```
Sets the given timestamp to the cell iff current timestamp is HConstants.LATEST_TIMESTAMP.

Parameters:

cell -

ts - buffer containing the timestamp value

tsOffset - offset to the new timestamp

Returns:

True if cell timestamp is modified.

Throws:

IOException - when the passed cell is not of type SettableTimestamp

writeFlatKey
```
public static void writeFlatKey(Cell cell,
                                DataOutputStream out)
                         throws IOException
```
Writes the Cell's key part as it would have serialized in a KeyValue. The format is <2 bytes rk len><rk><1 byte cf len><cf><qualifier><8 bytes timestamp><1 byte type>

Parameters:

cell -

out -

Throws:

IOException

writeFlatKey

public static int writeFlatKey(Cell cell,
                               OutputStream out)
                        throws IOException

Throws:: IOException

writeRow
```
public static void writeRow(OutputStream out,
                            Cell cell,
                            short rlength)
                     throws IOException
```
Writes the row from the given cell to the output stream

Parameters:

out - The outputstream to which the data has to be written

cell - The cell whose contents has to be written

rlength - the row length

Throws:

IOException

writeRowSkippingBytes

public static void writeRowSkippingBytes(DataOutputStream out,
                                         Cell cell,
                                         short rlength,
                                         int commonPrefix)
                                  throws IOException

Writes the row from the given cell to the output stream excluding the common prefix

Parameters:: out - The dataoutputstream to which the data has to be written; cell - The cell whose contents has to be written; rlength - the row length
Throws:: IOException

writeFamily
```
public static void writeFamily(OutputStream out,
                               Cell cell,
                               byte flength)
                        throws IOException
```
Writes the family from the given cell to the output stream

Parameters:

out - The outputstream to which the data has to be written

cell - The cell whose contents has to be written

flength - the family length

Throws:

IOException

writeQualifier
```
public static void writeQualifier(OutputStream out,
                                  Cell cell,
                                  int qlength)
                           throws IOException
```
Writes the qualifier from the given cell to the output stream

Parameters:

out - The outputstream to which the data has to be written

cell - The cell whose contents has to be written

qlength - the qualifier length

Throws:

IOException

writeQualifierSkippingBytes

public static void writeQualifierSkippingBytes(DataOutputStream out,
                                               Cell cell,
                                               int qlength,
                                               int commonPrefix)
                                        throws IOException

Writes the qualifier from the given cell to the output stream excluding the common prefix

Parameters:: out - The dataoutputstream to which the data has to be written; cell - The cell whose contents has to be written; qlength - the qualifier length
Throws:: IOException

writeValue
```
public static void writeValue(OutputStream out,
                              Cell cell,
                              int vlength)
                       throws IOException
```
Writes the value from the given cell to the output stream

Parameters:

out - The outputstream to which the data has to be written

cell - The cell whose contents has to be written

vlength - the value length

Throws:

IOException

writeTags
```
public static void writeTags(OutputStream out,
                             Cell cell,
                             int tagsLength)
                      throws IOException
```
Writes the tag from the given cell to the output stream

Parameters:

out - The outputstream to which the data has to be written

cell - The cell whose contents has to be written

tagsLength - the tag length

Throws:

IOException

getCellKeyAsString
```
public static String getCellKeyAsString(Cell cell)
```
Parameters:

cell -

Returns:

The Key portion of the passed cell as a String.

getCellKeySerializedAsKeyValueKey
```
public static byte[] getCellKeySerializedAsKeyValueKey(Cell cell)
```
This method exists just to encapsulate how we serialize keys. To be replaced by a factory that we query to figure what the Cell implementation is and then, what serialization engine to use and further, how to serialize the key for inclusion in hfile index. TODO.

Parameters:

cell -

Returns:

The key portion of the Cell serialized in the old-school KeyValue way or null if passed a null cell

writeRowKeyExcludingCommon

public static void writeRowKeyExcludingCommon(Cell cell,
                                              short rLen,
                                              int commonPrefix,
                                              DataOutputStream out)
                                       throws IOException

Write rowkey excluding the common part.

Parameters:: cell -; rLen -; commonPrefix -; out -
Throws:: IOException

findCommonPrefixInFlatKey
```
public static int findCommonPrefixInFlatKey(Cell c1,
                                            Cell c2,
                                            boolean bypassFamilyCheck,
                                            boolean withTsType)
```
Find length of common prefix in keys of the cells, considering key as byte[] if serialized in KeyValue. The key format is <2 bytes rk len><rk><1 byte cf len><cf><qualifier><8 bytes timestamp><1 byte type>

Parameters:

c1 - the cell

c2 - the cell

bypassFamilyCheck - when true assume the family bytes same in both cells. Pass it as true when dealing with Cells in same CF so as to avoid some checks

withTsType - when true check timestamp and type bytes also.

Returns:

length of common prefix

toString

public static String toString(Cell cell,
                              boolean verbose)

Returns a string representation of the cell

equalsIgnoreMvccVersion

public static boolean equalsIgnoreMvccVersion(Cell a,
                                              Cell b)

special case for Cell.equals

equals

public static boolean equals(Cell a,
                             Cell b)

equals

matchingTimestamp

public static boolean matchingTimestamp(Cell a,
                                        Cell b)

matchingType

public static boolean matchingType(Cell a,
                                   Cell b)

matchingRows

public static boolean matchingRows(Cell left,
                                   Cell right)

Compares the row of two keyvalues for equality

Parameters:: left -; right -
Returns:: True if rows match.

matchingRowColumn

public static boolean matchingRowColumn(Cell left,
                                        Cell right)

Compares the row and column of two keyvalues for equality

Parameters:: left -; right -
Returns:: True if same row and column.

getRowAsInt
```
public static int getRowAsInt(Cell cell)
```
Converts the rowkey bytes of the given cell into an int value

Parameters:

cell -

Returns:

rowkey as int

getValueAsLong
```
public static long getValueAsLong(Cell cell)
```
Converts the value bytes of the given cell into a long value

Parameters:

cell -

Returns:

value as long

getValueAsInt
```
public static int getValueAsInt(Cell cell)
```
Converts the value bytes of the given cell into a int value

Parameters:

cell -

Returns:

value as int

getValueAsDouble
```
public static double getValueAsDouble(Cell cell)
```
Converts the value bytes of the given cell into a double value

Parameters:

cell -

Returns:

value as double

getValueAsBigDecimal
```
public static BigDecimal getValueAsBigDecimal(Cell cell)
```
Converts the value bytes of the given cell into a BigDecimal

Parameters:

cell -

Returns:

value as BigDecimal

createFirstOnRow
```
public static Cell createFirstOnRow(Cell cell)
```
Create a Cell that is smaller than all other possible Cells for the given Cell's row.

Parameters:

cell -

Returns:

First possible Cell on passed Cell's row.

createFirstOnRow

public static Cell createFirstOnRow(byte[] row,
                                    int roffset,
                                    short rlength)

createFirstOnRow

public static Cell createFirstOnRow(byte[] row,
                                    byte[] family,
                                    byte[] col)

createFirstOnRow

public static Cell createFirstOnRow(byte[] row,
                                    int roffset,
                                    short rlength,
                                    byte[] family,
                                    int foffset,
                                    byte flength,
                                    byte[] col,
                                    int coffset,
                                    int clength)

createFirstOnRow

public static Cell createFirstOnRow(byte[] row)

createFirstOnRowFamily

public static Cell createFirstOnRowFamily(Cell cell,
                                          byte[] fArray,
                                          int foff,
                                          int flen)

Returns:: Cell that is smaller than all other possible Cells for the given Cell's row and passed family.

createFirstOnRowCol
```
public static Cell createFirstOnRowCol(Cell cell)
```
Create a Cell that is smaller than all other possible Cells for the given Cell's row. The family length is considered to be 0

Parameters:

cell -

Returns:

First possible Cell on passed Cell's row.

createFirstOnNextRow
```
public static Cell createFirstOnNextRow(Cell cell)
```
Create a Cell that is smaller than all other possible Cells for the given Cell row's next row. Makes the next row's rowkey by appending single byte 0x00 to the end of current row key.

createFirstOnRowCol
```
public static Cell createFirstOnRowCol(Cell cell,
                                       byte[] qArray,
                                       int qoffest,
                                       int qlength)
```
Create a Cell that is smaller than all other possible Cells for the given Cell's rk:cf and passed qualifier.

Parameters:

cell -

qArray -

qoffest -

qlength -

Returns:

Last possible Cell on passed Cell's rk:cf and passed qualifier.

createFirstOnRowColTS
```
public static Cell createFirstOnRowColTS(Cell cell,
                                         long ts)
```
Creates the first cell with the row/family/qualifier of this cell and the given timestamp. Uses the "maximum" type that guarantees that the new cell is the lowest possible for this combination of row, family, qualifier, and timestamp. This cell's own timestamp is ignored.

Parameters:

cell - - cell

ts -

createLastOnRow
```
public static Cell createLastOnRow(Cell cell)
```
Create a Cell that is larger than all other possible Cells for the given Cell's row.

Parameters:

cell -

Returns:

Last possible Cell on passed Cell's row.

createLastOnRow

public static Cell createLastOnRow(byte[] row)

createLastOnRowCol
```
public static Cell createLastOnRowCol(Cell cell)
```
Create a Cell that is larger than all other possible Cells for the given Cell's rk:cf:q. Used in creating "fake keys" for the multi-column Bloom filter optimization to skip the row/column we already know is not in the file.

Parameters:

cell -

Returns:

Last possible Cell on passed Cell's rk:cf:q.

createFirstDeleteFamilyCellOnRow
```
public static Cell createFirstDeleteFamilyCellOnRow(byte[] row,
                                                    byte[] fam)
```
Create a Delete Family Cell for the specified row and family that would be smaller than all other possible Delete Family KeyValues that have the same row and family. Used for seeking.

Parameters:

row - - row key (arbitrary byte array)

fam - - family name

Returns:

First Delete Family possible key on passed row.

compressTags

@InterfaceAudience.Private
public static void compressTags(OutputStream out,
                                                           Cell cell,
                                                           TagCompressionContext tagCompressionContext)
                                                    throws IOException

Compresses the tags to the given outputstream using the TagcompressionContext

Parameters:: out - the outputstream to which the compression should happen; cell - the cell which has tags; tagCompressionContext - the TagCompressionContext
Throws:: IOException - can throw IOException if the compression encounters issue

compressRow

@InterfaceAudience.Private
public static void compressRow(OutputStream out,
                                                          Cell cell,
                                                          Dictionary dict)
                                                   throws IOException

Throws:: IOException

compressFamily

@InterfaceAudience.Private
public static void compressFamily(OutputStream out,
                                                             Cell cell,
                                                             Dictionary dict)
                                                      throws IOException

Throws:: IOException

compressQualifier

@InterfaceAudience.Private
public static void compressQualifier(OutputStream out,
                                                                Cell cell,
                                                                Dictionary dict)
                                                         throws IOException

Throws:: IOException

Class CellUtil

Method Summary

Methods inherited from class java.lang.Object

Method Detail

fillRowRange

fillFamilyRange

fillQualifierRange

fillValueRange

fillTagRange

cloneRow

cloneFamily

cloneQualifier

cloneValue

cloneTags

getTagArray

copyRowTo

copyRowTo

copyRow

copyFamilyTo

copyFamilyTo

copyQualifierTo

copyQualifierTo

copyValueTo

copyValueTo

copyTagTo

copyTagTo

getRowByte

getQualifierByte

getValueBufferShallowCopy

getQualifierBufferShallowCopy

createCell

createCell

createCell

createCell

createCell

createCell

createCell

createCell

createCell

createCell

createCell

createCellScanner

createCellScanner

createCellScanner

createCellScanner

createCellScanner

matchingRow

matchingRow

matchingRow

matchingFamily

matchingFamily

matchingFamily

matchingQualifier

matchingQualifier

matchingQualifier

matchingColumn

matchingColumn

matchingColumn

matchingValue

matchingValue

matchingValue

isDelete

isDelete

isDeleteType

isDeleteFamily

isDeleteFamilyVersion

isDeleteColumns

isDeleteColumnVersion

isDeleteColumnOrFamily

estimatedSerializedSizeOf

estimatedSerializedSizeOfKey

estimatedHeapSizeOf

tagsIterator

tagsIterator

getTags

getTag

overlappingKeys

setSequenceId

setTimestamp

setTimestamp