Constructor Detail

• CellComparator

  public CellComparator()

Method Detail

• compare

  public int compare(Cell a,
            Cell b)

  Specified by:

  compare in interface Comparator<Cell>

• compare

  public static int compare(Cell a,
            Cell b,
            boolean ignoreSequenceid)

  Compare cells. TODO: Replace with dynamic rather than static comparator so can change comparator implementation.

  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.

• findCommonPrefixInRowPart

  public static int findCommonPrefixInRowPart(Cell left,
                              Cell right,
                              int rowCommonPrefix)

• findCommonPrefixInFamilyPart

  public static int findCommonPrefixInFamilyPart(Cell left,
                                 Cell right,
                                 int familyCommonPrefix)

• findCommonPrefixInQualifierPart

  public static int findCommonPrefixInQualifierPart(Cell left,
                                    Cell right,
                                    int qualifierCommonPrefix)

• equals

  public static boolean equals(Cell a,
               Cell b)

  equals

• equalsRow

  public static boolean equalsRow(Cell a,
                  Cell b)

• equalsFamily

  public static boolean equalsFamily(Cell a,
                     Cell b)

• equalsQualifier

  public static boolean equalsQualifier(Cell a,
                        Cell b)

• equalsTimestamp

  public static boolean equalsTimestamp(Cell a,
                        Cell b)

• equalsType

  public static boolean equalsType(Cell a,
                   Cell b)

• compareColumns

  public static int compareColumns(Cell left,
                   Cell right)

• compareFamilies

  public static int compareFamilies(Cell left,
                    Cell right)

• compareQualifiers

  public static int compareQualifiers(Cell left,
                      Cell right)

• compareFlatKey

  public int compareFlatKey(Cell left,
                   Cell right)

• compareRows

  public static int compareRows(Cell left,
                Cell right)

  Do not use comparing rows from hbase:meta. Meta table Cells have schema (table,startrow,hash) so can't be treated as plain byte arrays as this method does.

• compareRows

  public static int compareRows(byte[] left,
                int loffset,
                int llength,
                byte[] right,
                int roffset,
                int rlength)

  Do not use comparing rows from hbase:meta. Meta table Cells have schema (table,startrow,hash) so can't be treated as plain byte arrays as this method does.

• compareWithoutRow

  public static int compareWithoutRow(Cell leftCell,
                      Cell rightCell)

• 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

• hashCode

  public static int hashCode(Cell cell)

  Returns a hash code that is always the same for two Cells having a matching equals(..) result.

• hashCodeIgnoreMvcc

  public static int hashCodeIgnoreMvcc(Cell cell)

  Returns a hash code that is always the same for two Cells having a matching equals(..) result. Note : Ignore mvcc while calculating the hashcode

  Parameters:

  cell -

  Returns:

  hashCode

• areKeyLengthsEqual

  public static boolean areKeyLengthsEqual(Cell a,
                           Cell b)

  lengths

• areRowLengthsEqual

  public static boolean areRowLengthsEqual(Cell a,
                           Cell b)

• compareCommonRowPrefix

  public static int compareCommonRowPrefix(Cell left,
                           Cell right,
                           int rowCommonPrefix)

• compareCommonFamilyPrefix

  public static int compareCommonFamilyPrefix(Cell left,
                              Cell right,
                              int familyCommonPrefix)

• compareCommonQualifierPrefix

  public static int compareCommonQualifierPrefix(Cell left,
                                 Cell right,
                                 int qualCommonPrefix)

• equalsIgnoreMvccVersion

  public static boolean equalsIgnoreMvccVersion(Cell a,
                                Cell b)

  special case for KeyValue.equals

• getMidpoint

  public static Cell getMidpoint(KeyValue.KVComparator comparator,
                 Cell left,
                 Cell right)

  Try to return a Cell that falls between left and right but that is shorter; i.e. takes up less space. This trick is used building HFile block index. Its an optimization. It does not always work. In this case we'll just return the right cell.

  Parameters:

  comparator - Comparator to use.

  left -

  right -

  Returns:

  A cell that sorts between left and right.