org.apache.hadoop.hbase

Class CellComparator

java.lang.Object

org.apache.hadoop.hbase.CellComparator

All Implemented Interfaces:

Serializable, Comparator<Cell>

Direct Known Subclasses:

CellComparator.MetaCellComparator

@InterfaceAudience.Private
 @InterfaceStability.Evolving
public class CellComparator
extends Object
implements Comparator<Cell>, Serializable

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

See Also:

Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	CellComparator.MetaCellComparator A CellComparator for hbase:meta catalog table KeyValues.

Field Summary

Fields

Modifier and Type	Field and Description
static CellComparator	COMPARATOR Comparator for plain key/values; i.e.
static CellComparator	META_COMPARATOR A CellComparator for hbase:meta catalog table KeyValues.

Constructor Summary

Constructors

Constructor and Description
CellComparator()

Method Summary

Modifier and Type	Method and Description
int	compare(Cell left, byte[] key, int offset, int length) Used when a cell needs to be compared with a key byte[] such as cases of finding the index from the index block, bloom keys from the bloom blocks This byte[] is expected to be serialized in the KeyValue serialization format If the KeyValue (Cell's) serialization format changes this method cannot be used.
int	compare(Cell a, Cell b)
static int	compareColumns(Cell left, Cell right) Compares the family and qualifier part of the cell
static int	compareFamilies(Cell left, Cell right) Compare the families of left and right cell
static int	compareFamily(Cell cell, ByteArrayComparable comparator) Compare cell's column family against given comparator
int	compareKeyBasedOnColHint(Cell nextIndexedCell, Cell currentCell, int foff, int flen, byte[] colHint, int coff, int clen, long ts, byte type) Used to compare two cells based on the column hint provided.
int	compareKeyIgnoresMvcc(Cell left, Cell right) Compares only the key portion of a cell.
static int	compareQualifier(Cell cell, ByteArrayComparable comparator) Compare cell's qualifier against given comparator
static int	compareQualifiers(Cell left, byte[] right, int rOffset, int rLength)
static int	compareQualifiers(Cell left, Cell right) Compare the qualifiers part of the left and right cells.
static int	compareRow(Cell cell, ByteArrayComparable comparator) Compare cell's row against given comparator
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.
static int	compareTimestamps(Cell left, Cell right) Compares cell's timestamps in DESCENDING order.
static int	compareTimestamps(long ltimestamp, long rtimestamp) Compares timestamps in DESCENDING order.
static int	compareValue(Cell cell, ByteArrayComparable comparator) Compare cell's value against given comparator
static int	compareWithoutRow(Cell left, Cell right)

Methods inherited from class java.lang.Object

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

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

COMPARATOR

public static final CellComparator COMPARATOR

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

META_COMPARATOR

public static final CellComparator META_COMPARATOR

A CellComparator for hbase:meta catalog table KeyValues.

Constructor Detail

CellComparator

public CellComparator()

Method Detail

compare

public int compare(Cell a,
                   Cell b)

Specified by:

compare in interface Comparator<Cell>

compareKeyIgnoresMvcc

public final int compareKeyIgnoresMvcc(Cell left,
                                       Cell right)

Compares only the key portion of a cell. It does not include the sequence id/mvcc of the cell

Parameters:

left -

right -

Returns:

an int greater than 0 if left > than right lesser than 0 if left < than right equal to 0 if left is equal to right

compare

public final int compare(Cell left,
                         byte[] key,
                         int offset,
                         int length)

Used when a cell needs to be compared with a key byte[] such as cases of finding the index from the index block, bloom keys from the bloom blocks This byte[] is expected to be serialized in the KeyValue serialization format If the KeyValue (Cell's) serialization format changes this method cannot be used.

Parameters:

left - the cell to be compared

key - the serialized key part of a KeyValue

offset - the offset in the key byte[]

length - the length of the key byte[]

Returns:

an int greater than 0 if left is greater than right lesser than 0 if left is lesser than right equal to 0 if left is equal to right

compareColumns

public static final int compareColumns(Cell left,
                                       Cell right)

Compares the family and qualifier part of the cell

Parameters:

left - the left cell

right - the right cell

Returns:

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

compareFamilies

public static final int compareFamilies(Cell left,
                                        Cell right)

Compare the families of left and right cell

Parameters:

left -

right -

Returns:

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

compareQualifiers

public static final int compareQualifiers(Cell left,
                                          Cell right)

Compare the qualifiers part of the left and right cells.

Parameters:

left -

right -

Returns:

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

compareQualifiers

public static final int compareQualifiers(Cell left,
                                          byte[] right,
                                          int rOffset,
                                          int rLength)

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.

Parameters:

left -

right -

Returns:

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

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 {META_COMPARATOR should be used

Parameters:

left - the cell to be compared

right - the kv serialized byte[] to be compared with

roffset - the offset in the byte[]

rlength - the length in the byte[]

Returns:

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

compareWithoutRow

public static int compareWithoutRow(Cell left,
                                    Cell right)

compareTimestamps

public static int compareTimestamps(Cell left,
                                    Cell right)

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.

Returns:

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

compareKeyBasedOnColHint

public final int compareKeyBasedOnColHint(Cell nextIndexedCell,
                                          Cell currentCell,
                                          int foff,
                                          int flen,
                                          byte[] colHint,
                                          int coff,
                                          int clen,
                                          long ts,
                                          byte type)

Used to compare two cells based on the column hint provided. This is specifically used when we need to optimize the seeks based on the next indexed key. This is an advanced usage API specifically needed for some optimizations.

Parameters:

nextIndexedCell - the next indexed cell

currentCell - the cell to be compared

foff - the family offset of the currentCell

flen - the family length of the currentCell

colHint - the column hint provided - could be null

coff - the offset of the column hint if provided, if not offset of the currentCell's qualifier

clen - the length of the column hint if provided, if not length of the currentCell's qualifier

ts - the timestamp to be seeked

type - the type to be seeked

Returns:

an int based on the given column hint TODO : To be moved out of here because this is a special API used in scan optimization.

compareTimestamps

public static int compareTimestamps(long ltimestamp,
                                    long rtimestamp)

Compares 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.

Returns:

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

compareRow

public static int compareRow(Cell cell,
                             ByteArrayComparable comparator)

Compare cell's row against given comparator

Parameters:

cell -

comparator -

Returns:

result comparing cell's row

compareFamily

public static int compareFamily(Cell cell,
                                ByteArrayComparable comparator)

Compare cell's column family against given comparator

Parameters:

cell -

comparator -

Returns:

result comparing cell's column family

compareQualifier

public static int compareQualifier(Cell cell,
                                   ByteArrayComparable comparator)

Compare cell's qualifier against given comparator

Parameters:

cell -

comparator -

Returns:

result comparing cell's qualifier

compareValue

public static int compareValue(Cell cell,
                               ByteArrayComparable comparator)

Compare cell's value against given comparator

Parameters:

cell -

comparator -

Returns:

result comparing cell's value