org.apache.hadoop.hbase

Class CellComparatorImpl

java.lang.Object

org.apache.hadoop.hbase.CellComparatorImpl

All Implemented Interfaces:

Comparator<Cell>, CellComparator

Direct Known Subclasses:

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

Nested Class Summary

Nested Classes

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

Field Summary

Fields

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

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 a, Cell b, boolean ignoreSequenceid) Compare cells.
int	compareColumns(Cell left, Cell right) Compares the family and qualifier part of the cell
int	compareFamilies(Cell left, Cell right) Compare the families of left and right cell
int	compareQualifiers(Cell left, Cell right) Compare the qualifiers part of the left and right cells.
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.
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) Lexographically compares the two cells excluding the row part.
Comparator	getSimpleComparator()

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

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

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.

META_COMPARATOR

public static final CellComparatorImpl META_COMPARATOR

A CellComparatorImpl for hbase:meta catalog table KeyValues.

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 a,
                   Cell b,
                   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.

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

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

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

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

Specified by:

compareRows in interface CellComparator

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 final int compareWithoutRow(Cell left,
                                   Cell right)

Description copied from interface: CellComparator

Lexographically 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()

Specified by:

getSimpleComparator in interface CellComparator

Returns:

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.