HBASE-26635 Optimize decodeNumeric in OrderedBytes

hbase-common/src/main/java/org/apache/hadoop/hbase/util/OrderedBytes.java

@@ -556,8 +556,8 @@ private static BigDecimal decodeSignificand(PositionedByteRange src, int e, bool
     byte[] a = src.getBytes();
     final int start = src.getPosition(), offset = src.getOffset(), remaining = src.getRemaining();
     Order ord = comp ? DESCENDING : ASCENDING;
-    BigDecimal m = BigDecimal.ZERO;
-    e--;
+    BigDecimal m;
+    StringBuilder sb = new StringBuilder();
     for (int i = 0;; i++) {
       if (i > remaining) {
         // we've exceeded this range's window
@@ -566,18 +566,23 @@ private static BigDecimal decodeSignificand(PositionedByteRange src, int e, bool
             "Read exceeds range before termination byte found. offset: " + offset + " position: "
                 + (start + i));
       }
+      // one byte -> 2 digits
       // base-100 digits are encoded as val * 2 + 1 except for the termination digit.
-      m = m.add( // m +=
-        new BigDecimal(BigInteger.ONE, e * -2).multiply( // 100 ^ p * [decoded digit]
-          BigDecimal.valueOf((ord.apply(a[offset + start + i]) & 0xff) / 2)));
-      e--;
+      int twoDigits = (ord.apply(a[offset + start + i]) & 0xff) / 2;
+      sb.append(String.format("%02d", twoDigits));
       // detect termination digit
-      if ((ord.apply(a[offset + start + i]) & 1) == 0) {
+      // Besides, as we will normalise the return value at last,
+      // we only need to decode at most MAX_PRECISION + 2 digits here.
+      if ((ord.apply(a[offset + start + i]) & 1) == 0 || sb.length() > MAX_PRECISION + 1) {
         src.setPosition(start + i + 1);
         break;
       }
     }
-    return normalize(m);
+    m = new BigDecimal(sb.toString());
+    int stepsMoveLeft = sb.charAt(0) != '0' ? m.precision() : m.precision() + 1;
+    stepsMoveLeft -= e * 2;
+
+    return normalize(m.movePointLeft(stepsMoveLeft));
   }
 
   /**

hbase-common/src/test/java/org/apache/hadoop/hbase/util/TestOrderedBytes.java

@@ -25,6 +25,7 @@
 import java.math.BigDecimal;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.Random;
 import org.apache.hadoop.hbase.HBaseClassTestRule;
 import org.apache.hadoop.hbase.testclassification.MiscTests;
 import org.apache.hadoop.hbase.testclassification.SmallTests;
@@ -1319,4 +1320,20 @@ public void testEncodedValueCheck() {
       OrderedBytes.skip(buff);
     }
   }
+
+  @Test
+  public void testEncodeDecodeMatch() {
+    BigDecimal[] randomData = new BigDecimal[200];
+    Random rand = new Random(System.currentTimeMillis());
+    for (int i = 0; i < randomData.length; i++) {
+      randomData[i] = BigDecimal.valueOf(rand.nextDouble() + rand.nextLong());
+      PositionedByteRange tmp = new SimplePositionedMutableByteRange(100);
+      Order ord = rand.nextBoolean() ? Order.DESCENDING : Order.ASCENDING;
+      OrderedBytes.encodeNumeric(tmp, randomData[i], ord);
+      tmp.setPosition(0);
+      BigDecimal left = OrderedBytes.normalize(randomData[i]);
+      BigDecimal right = OrderedBytes.decodeNumericAsBigDecimal(tmp);
+      assertEquals(0, left.compareTo(right));
+    }
+  }
 }