org.apache.hadoop.hbase

Class CellComparatorImpl

java.lang.Object

org.apache.hadoop.hbase.CellComparatorImpl

All Implemented Interfaces:

Serializable, Comparator<Cell>, CellComparator

Direct Known Subclasses:

MetaCellComparator

@InterfaceAudience.Private
 @InterfaceStability.Evolving
public class CellComparatorImpl
extends Object
implements CellComparator

Compare two HBase cells. Do not use this method comparing -ROOT- or hbase:meta cells. Cells from these tables need a specialized comparator, one that takes account of the special formatting of the row where we have commas to delimit table from regionname, from row. See KeyValue for how it has a special comparator to do hbase:meta cells and yet another for -ROOT-.

While using this comparator for {compareRows(Cell, Cell) et al, the hbase:meta cells format should be taken into consideration, for which the instance of this comparator should be used. In all other cases the static APIs in this comparator would be enough

HOT methods. We spend a good portion of CPU comparing. Anything that makes the compare faster will likely manifest at the macro level. See also BBKVComparator. Use it when mostly ByteBufferKeyValues.

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
static CellComparatorImpl	COMPARATOR Comparator for plain key/values; i.e.
private static long	serialVersionUID

Constructor Summary

Constructors

Constructor and Description
CellComparatorImpl()

Method Summary

Modifier and Type	Method and Description
int	compare(Cell a, Cell b) Lexographically compares two cells.
int	compare(Cell l, Cell r, boolean ignoreSequenceid) Compare cells.
private static int	compareBBKV(ByteBufferKeyValue left, ByteBufferKeyValue right)
int	compareColumns(Cell left, Cell right) Compares the family and qualifier part of the cell
private int	compareColumns(Cell left, int leftFamLen, int leftQualLen, Cell right, int rightFamLen, int rightQualLen)
int	compareFamilies(Cell left, Cell right) Compare the families of left and right cell
private int	compareFamilies(Cell left, int leftFamLen, Cell right, int rightFamLen)
private static int	compareKeyValues(KeyValue left, KeyValue right)
private static int	compareKVVsBBKV(KeyValue left, ByteBufferKeyValue right)
(package private) static int	compareQualifiers(ByteBufferKeyValue left, ByteBufferKeyValue right)
(package private) static int	compareQualifiers(ByteBufferKeyValue left, KeyValue right)
int	compareQualifiers(Cell left, Cell right) Compare the qualifiers part of the left and right cells.
private int	compareQualifiers(Cell left, int leftQualLen, Cell right, int rightQualLen)
(package private) static int	compareQualifiers(KeyValue left, ByteBufferKeyValue right)
(package private) static int	compareQualifiers(KeyValue left, KeyValue right)
int	compareRows(Cell left, byte[] right, int roffset, int rlength) Compares the row part of the cell with a simple plain byte[] like the stopRow in Scan.
int	compareRows(Cell left, Cell right) Compares the rows of the left and right cell.
(package private) static int	compareRows(Cell left, int leftRowLength, Cell right, int rightRowLength)
int	compareTimestamps(Cell left, Cell right) Compares cell's timestamps in DESCENDING order.
int	compareTimestamps(long ltimestamp, long rtimestamp) Compares cell's timestamps in DESCENDING order.
int	compareWithoutRow(Cell left, Cell right) Lexicographically compares the two cells excluding the row part.
static CellComparator	getCellComparator(byte[] tableName) Utility method that makes a guess at comparator to use based off passed tableName.
static CellComparator	getCellComparator(TableName tableName) Utility method that makes a guess at comparator to use based off passed tableName.
Comparator	getSimpleComparator() Return a dumbed-down, fast comparator for hbase2 base-type, the ByteBufferKeyValue.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.apache.hadoop.hbase.CellComparator

compareRows, compareRows, getInstance

Methods inherited from interface java.util.Comparator

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

Field Detail

serialVersionUID

private static final long serialVersionUID

See Also:

Constant Field Values

COMPARATOR

public static final CellComparatorImpl COMPARATOR

Comparator for plain key/values; i.e. non-catalog table key/values. Works on Key portion of KeyValue only.

Constructor Detail

CellComparatorImpl

public CellComparatorImpl()

Method Detail

compare

public final int compare(Cell a,
                         Cell b)

Description copied from interface: CellComparator

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>

Specified by:

compare in interface CellComparator

Parameters:

a - the left hand side cell

b - 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

public int compare(Cell l,
                   Cell r,
                   boolean ignoreSequenceid)

Description copied from interface: CellComparator

Compare cells.

Specified by:

compare in interface CellComparator

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.

compareKeyValues

private static int compareKeyValues(KeyValue left,
                                    KeyValue right)

compareBBKV

private static int compareBBKV(ByteBufferKeyValue left,
                               ByteBufferKeyValue right)

compareKVVsBBKV

private static int compareKVVsBBKV(KeyValue left,
                                   ByteBufferKeyValue right)

compareColumns

public final int compareColumns(Cell left,
                                Cell right)

Compares the family and qualifier part of the cell

Returns:

0 if both cells are equal, 1 if left cell is bigger than right, -1 otherwise

compareColumns

private int compareColumns(Cell left,
                           int leftFamLen,
                           int leftQualLen,
                           Cell right,
                           int rightFamLen,
                           int rightQualLen)

compareFamilies

private int compareFamilies(Cell left,
                            int leftFamLen,
                            Cell right,
                            int rightFamLen)

compareQualifiers

private final int compareQualifiers(Cell left,
                                    int leftQualLen,
                                    Cell right,
                                    int rightQualLen)

compareFamilies

public final int compareFamilies(Cell left,
                                 Cell right)

Compare the families of left and right cell

Specified by:

compareFamilies in interface CellComparator

Parameters:

left - the left hand side cell

right - the right hand side cell

Returns:

0 if both cells are equal, 1 if left cell is bigger than right, -1 otherwise

compareQualifiers

static int compareQualifiers(KeyValue left,
                             KeyValue right)

compareQualifiers

static int compareQualifiers(KeyValue left,
                             ByteBufferKeyValue right)

compareQualifiers

static int compareQualifiers(ByteBufferKeyValue left,
                             KeyValue right)

compareQualifiers

static int compareQualifiers(ByteBufferKeyValue left,
                             ByteBufferKeyValue right)

compareQualifiers

public final int compareQualifiers(Cell left,
                                   Cell right)

Compare the qualifiers part of the left and right cells.

Specified by:

compareQualifiers in interface CellComparator

Parameters:

left - the left hand side cell

right - the right hand side cell

Returns:

0 if both cells are equal, 1 if left cell is bigger than right, -1 otherwise

compareRows

public int compareRows(Cell left,
                       Cell right)

Compares the rows of the left and right cell. For the hbase:meta case this method is overridden such that it can handle hbase:meta cells. The caller should ensure using the appropriate comparator for hbase:meta.

Specified by:

compareRows in interface CellComparator

Parameters:

left - the left hand side cell

right - the right hand side cell

Returns:

0 if both cells are equal, 1 if left cell is bigger than right, -1 otherwise

compareRows

static int compareRows(Cell left,
                       int leftRowLength,
                       Cell right,
                       int rightRowLength)

compareRows

public int compareRows(Cell left,
                       byte[] right,
                       int roffset,
                       int rlength)

Compares the row part of the cell with a simple plain byte[] like the stopRow in Scan. This should be used with context where for hbase:meta cells the {MetaCellComparator.META_COMPARATOR should be used n * the cell to be compared n * the kv serialized byte[] to be compared with n * the offset in the byte[] n * the length in the byte[]

Specified by:

compareRows in interface CellComparator

Parameters:

left - the cell

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

roffset - the offset of the byte[]

rlength - the length of the byte[]

Returns:

0 if both cell and the byte[] are equal, 1 if the cell is bigger than byte[], -1 otherwise

compareWithoutRow

public final int compareWithoutRow(Cell left,
                                   Cell right)

Description copied from interface: CellComparator

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

Specified by:

compareWithoutRow in interface CellComparator

Parameters:

left - the left hand side cell

right - 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

public int compareTimestamps(Cell left,
                             Cell right)

Description copied from interface: CellComparator

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.

Specified by:

compareTimestamps in interface CellComparator

Parameters:

left - the left hand side cell

right - 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

public int compareTimestamps(long ltimestamp,
                             long rtimestamp)

Description copied from interface: CellComparator

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.

Specified by:

compareTimestamps in interface CellComparator

Parameters:

ltimestamp - the left cell's timestamp

rtimestamp - 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

public Comparator getSimpleComparator()

Description copied from interface: CellComparator

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.

Specified by:

getSimpleComparator in interface CellComparator

getCellComparator

public static CellComparator getCellComparator(TableName tableName)

Utility method that makes a guess at comparator to use based off passed tableName. Use in extreme when no comparator specified.

Returns:

CellComparator to use going off the tableName passed.

getCellComparator

public static CellComparator getCellComparator(byte[] tableName)

Utility method that makes a guess at comparator to use based off passed tableName. Use in extreme when no comparator specified.

Returns:

CellComparator to use going off the tableName passed.