HBASE-22937 The RawBytesComparator in branch-1 have wrong comparison order (#582)

Author: openinx

hbase-common/src/main/java/org/apache/hadoop/hbase/KeyValue.java

@@ -2630,9 +2630,8 @@ int compareIgnoringPrefix(int commonPrefix, byte[] left, int loffset, int llengt
    */
   public static class RawBytesComparator extends KVComparator {
     /**
-     * The HFileV2 file format's trailer contains this class name.  We reinterpret this and
-     * instantiate the appropriate comparator.
-     * TODO: With V3 consider removing this.
+     * The HFileV2 file format's trailer contains this class name. We reinterpret this and
+     * instantiate the appropriate comparator. TODO: With V3 consider removing this.
      * @return legacy class name for FileFileTrailer#comparatorClassName
      */
     @Override
@@ -2645,9 +2644,9 @@ public String getLegacyKeyComparatorName() {
      */
     @Override
     @Deprecated
-    public int compareFlatKey(byte[] left, int loffset, int llength, byte[] right,
-        int roffset, int rlength) {
-      return Bytes.BYTES_RAWCOMPARATOR.compare(left,  loffset, llength, right, roffset, rlength);
+    public int compareFlatKey(byte[] left, int loffset, int llength, byte[] right, int roffset,
+        int rlength) {
+      return Bytes.BYTES_RAWCOMPARATOR.compare(left, loffset, llength, right, roffset, rlength);
     }
 
     @Override
@@ -2659,34 +2658,33 @@ public int compare(Cell left, Cell right) {
     @VisibleForTesting
     public int compareOnlyKeyPortion(Cell left, Cell right) {
       int c = Bytes.BYTES_RAWCOMPARATOR.compare(left.getRowArray(), left.getRowOffset(),
-          left.getRowLength(), right.getRowArray(), right.getRowOffset(), right.getRowLength());
+        left.getRowLength(), right.getRowArray(), right.getRowOffset(), right.getRowLength());
       if (c != 0) {
         return c;
       }
       c = Bytes.BYTES_RAWCOMPARATOR.compare(left.getFamilyArray(), left.getFamilyOffset(),
-          left.getFamilyLength(), right.getFamilyArray(), right.getFamilyOffset(),
-          right.getFamilyLength());
+        left.getFamilyLength(), right.getFamilyArray(), right.getFamilyOffset(),
+        right.getFamilyLength());
       if (c != 0) {
         return c;
       }
       c = Bytes.BYTES_RAWCOMPARATOR.compare(left.getQualifierArray(), left.getQualifierOffset(),
-          left.getQualifierLength(), right.getQualifierArray(), right.getQualifierOffset(),
-          right.getQualifierLength());
+        left.getQualifierLength(), right.getQualifierArray(), right.getQualifierOffset(),
+        right.getQualifierLength());
       if (c != 0) {
         return c;
       }
       c = compareTimestamps(left.getTimestamp(), right.getTimestamp());
       if (c != 0) {
         return c;
       }
-      return (0xff & left.getTypeByte()) - (0xff & right.getTypeByte());
+      return (0xff & right.getTypeByte()) - (0xff & left.getTypeByte());
     }
 
     @Override
     public byte[] calcIndexKey(byte[] lastKeyOfPreviousBlock, byte[] firstKeyInBlock) {
       return firstKeyInBlock;
     }
-
   }
 
   /**

hbase-common/src/test/java/org/apache/hadoop/hbase/TestKeyValue.java

@@ -38,6 +38,7 @@
 import org.apache.commons.logging.LogFactory;
 import org.apache.hadoop.hbase.KeyValue.KVComparator;
 import org.apache.hadoop.hbase.KeyValue.MetaComparator;
+import org.apache.hadoop.hbase.KeyValue.Type;
 import org.apache.hadoop.hbase.testclassification.SmallTests;
 import org.apache.hadoop.hbase.util.ByteBufferUtils;
 import org.apache.hadoop.hbase.util.Bytes;
@@ -722,4 +723,16 @@ public void testCheckKeyValueBytesFailureCase() throws Exception {
       }
     }
   }
+
+  @Test
+  public void testRawBytesComparator() {
+    long ts = System.currentTimeMillis();
+    byte[] key = Bytes.toBytes("key");
+    byte[] cf = Bytes.toBytes("cf");
+    byte[] qualifier = Bytes.toBytes("qualifier");
+    byte[] value = Bytes.toBytes("value");
+    KeyValue kvA1 = new KeyValue(key, cf, qualifier, ts, Type.Put, value);
+    KeyValue kvA2 = new KeyValue(key, cf, qualifier, ts, Type.DeleteFamily, value);
+    assertTrue(KeyValue.RAW_COMPARATOR.compare(kvA1, kvA2) > 0);
+  }
 }