CellComparatorImpl (Apache HBase - Common 2.0.0-alpha4 API)

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

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class CellComparatorImpl.MetaCellComparator
A CellComparatorImpl for hbase:meta catalog table KeyValues.

Nested Classes
Modifier and Type	Class and Description
`static class`	`CellComparatorImpl.MetaCellComparator` A `CellComparatorImpl` for `hbase:meta` catalog table `KeyValue`s.

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 `KeyValue`s.

Constructor Summary

Constructors
Constructor and Description

CellComparatorImpl()

Constructors
Constructor and Description
`CellComparatorImpl()`

Method Summary

All Methods Instance Methods Concrete Methods
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 timestamps in DESCENDING order.
`int`	`compareWithoutRow(Cell left, Cell right)` Lexographically compares the two cells excluding the row part.

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 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 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 final int compare(Cell a,
                         Cell b,
                         boolean ignoreSequenceid)
```
    Compare cells.
    
    Parameters:
    
    a -
    
    b -
    
    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
    
    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 final int compareFamilies(Cell left,
                                 Cell right)
```
    Compare the families of left and right cell
    
    Specified by:
    
    compareFamilies in interface CellComparator
    
    Parameters:
    
    left -
    
    right -
    
    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 -
    
    right -
    
    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 -
    
    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
    
    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)
```
    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)
```
    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.
    
    Specified by:
    
    compareTimestamps in interface CellComparator
    
    Parameters:
    
    ltimestamp - the left cell's timestamp
    
    rtimestamp - the right cell's timestamp
    
    Returns:
    
    1 if left timestamp < right timestamp -1 if left timestamp > right timestamp 0 if both timestamps are equal

Class CellComparatorImpl

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Comparator

Field Detail

COMPARATOR

META_COMPARATOR

Constructor Detail

CellComparatorImpl

Method Detail

compare

compare

compareColumns

compareFamilies

compareQualifiers

compareRows

compareRows

compareWithoutRow

compareTimestamps

compareTimestamps