org.apache.hadoop.hbase

Interface CellComparator

All Superinterfaces:

Comparator<Cell>, Serializable

@InterfaceAudience.Public
 @InterfaceStability.Evolving
public interface CellComparator
extends Comparator<Cell>, Serializable

Comparator for comparing cells and has some specialized methods that allows comparing individual cell components like row, family, qualifier and timestamp

Method Summary

Modifier and Type	Method and Description
int	compare(Cell leftCell, Cell rightCell) Lexographically compares two cells.
int	compare(Cell leftCell, Cell rightCell, boolean ignoreSequenceid) Compare cells.
int	compareFamilies(Cell leftCell, Cell rightCell) Lexicographically compares the families of the two cells
int	compareQualifiers(Cell leftCell, Cell rightCell) Lexicographically compares the qualifiers of the two cells
default int	compareRows(byte[] leftRow, byte[] rightRow) Compares two row bytes
default int	compareRows(ByteBuffer row, Cell cell) Lexicographically compare two rows
int	compareRows(Cell cell, byte[] bytes, int offset, int length) Compares the row part of the cell with a simple plain byte[] like the stopRow in Scan.
int	compareRows(Cell leftCell, Cell rightCell) Lexographically compares the rows of two cells.
int	compareTimestamps(Cell leftCell, Cell rightCell) Compares cell's timestamps in DESCENDING order.
int	compareTimestamps(long leftCellts, long rightCellts) Compares cell's timestamps in DESCENDING order.
int	compareWithoutRow(Cell leftCell, Cell rightCell) Lexicographically compares the two cells excluding the row part.
static CellComparator	getInstance() A comparator for ordering cells in user-space tables.
Comparator<Cell>	getSimpleComparator() Return a dumbed-down, fast comparator for hbase2 base-type, the ByteBufferKeyValue.

Methods inherited from interface java.util.Comparator

comparing, comparing, comparingDouble, comparingInt, comparingLong, equals, naturalOrder, nullsFirst, nullsLast, reversed, reverseOrder, thenComparing, thenComparing, thenComparing, thenComparingDouble, thenComparingInt, thenComparingLong

Method Detail

getInstance

static CellComparator getInstance()

A comparator for ordering cells in user-space tables. Useful when writing cells in sorted order as necessary for bulk import (i.e. via MapReduce).

CAUTION: This comparator may provide inaccurate ordering for cells from system tables, and should not be relied upon in that case.

compare

int compare(Cell leftCell,
            Cell rightCell)

Lexographically compares two cells. The key part of the cell is taken for comparison which includes row, family, qualifier, timestamp and type

Specified by:

compare in interface Comparator<Cell>

Parameters:

leftCell - the left hand side cell

rightCell - the right hand side cell

Returns:

greater than 0 if leftCell is bigger, less than 0 if rightCell is bigger, 0 if both cells are equal

compare

int compare(Cell leftCell,
            Cell rightCell,
            boolean ignoreSequenceid)

Compare cells.

Parameters:

ignoreSequenceid - True if we are to compare the key portion only and ignore the sequenceid. Set to false to compare key and consider sequenceid.

Returns:

0 if equal, -1 if a < b, and +1 if a > b.

compareRows

int compareRows(Cell leftCell,
                Cell rightCell)

Lexographically compares the rows of two cells.

Parameters:

leftCell - the left hand side cell

rightCell - the right hand side cell

Returns:

greater than 0 if leftCell is bigger, less than 0 if rightCell is bigger, 0 if both cells are equal

compareRows

int compareRows(Cell cell,
                byte[] bytes,
                int offset,
                int length)

Compares the row part of the cell with a simple plain byte[] like the stopRow in Scan.

Parameters:

cell - the cell

bytes - the byte[] representing the row to be compared with

offset - the offset of the byte[]

length - the length of the byte[]

Returns:

greater than 0 if leftCell is bigger, less than 0 if rightCell is bigger, 0 if both cells are equal

compareRows

default int compareRows(byte[] leftRow,
                        byte[] rightRow)

Compares two row bytes

Parameters:

leftRow - the byte array of the left row

rightRow - the byte array of the right row

Returns:

greater than 0 if leftRow is bigger, less than 0 if rightRow is bigger, 0 if both rows are equal

compareRows

default int compareRows(ByteBuffer row,
                        Cell cell)

Lexicographically compare two rows

Parameters:

row - ByteBuffer that wraps a row; will read from current position and will reading all remaining; will not disturb the ByteBuffer internal state.

Returns:

greater than 0 if leftCell is bigger, less than 0 if rightCell is bigger, 0 if both cells are equal

compareWithoutRow

int compareWithoutRow(Cell leftCell,
                      Cell rightCell)

Lexicographically compares the two cells excluding the row part. It compares family, qualifier, timestamp and the type

Parameters:

leftCell - the left hand side cell

rightCell - the right hand side cell

Returns:

greater than 0 if leftCell is bigger, less than 0 if rightCell is bigger, 0 if both cells are equal

compareFamilies

int compareFamilies(Cell leftCell,
                    Cell rightCell)

Lexicographically compares the families of the two cells

Parameters:

leftCell - the left hand side cell

rightCell - the right hand side cell

Returns:

greater than 0 if leftCell is bigger, less than 0 if rightCell is bigger, 0 if both cells are equal

compareQualifiers

int compareQualifiers(Cell leftCell,
                      Cell rightCell)

Lexicographically compares the qualifiers of the two cells

Parameters:

leftCell - the left hand side cell

rightCell - the right hand side cell

Returns:

greater than 0 if leftCell is bigger, less than 0 if rightCell is bigger, 0 if both cells are equal

compareTimestamps

int compareTimestamps(Cell leftCell,
                      Cell rightCell)

Compares cell's timestamps in DESCENDING order. The below older timestamps sorting ahead of newer timestamps looks wrong but it is intentional. This way, newer timestamps are first found when we iterate over a memstore and newer versions are the first we trip over when reading from a store file.

Parameters:

leftCell - the left hand side cell

rightCell - the right hand side cell

Returns:

1 if left's timestamp < right's timestamp -1 if left's timestamp > right's timestamp 0 if both timestamps are equal

compareTimestamps

int compareTimestamps(long leftCellts,
                      long rightCellts)

Compares cell's timestamps in DESCENDING order. The below older timestamps sorting ahead of newer timestamps looks wrong but it is intentional. This way, newer timestamps are first found when we iterate over a memstore and newer versions are the first we trip over when reading from a store file.

Parameters:

leftCellts - the left cell's timestamp

rightCellts - the right cell's timestamp

Returns:

1 if left's timestamp < right's timestamp -1 if left's timestamp > right's timestamp 0 if both timestamps are equal

getSimpleComparator

Comparator<Cell> getSimpleComparator()

Return a dumbed-down, fast comparator for hbase2 base-type, the ByteBufferKeyValue. Create an instance when you make a new memstore, when you know only BBKVs will be passed. Do not pollute with types other than BBKV if can be helped; the Comparator will slow.