Updated compareTo implementation for UUID, Decimal, Void and Null

Author: alex268

table/src/main/java/tech/ydb/table/values/DecimalValue.java

@@ -289,52 +289,14 @@ public int compareTo(Value<?> other) {
 
         DecimalValue decimal = (DecimalValue) other;
 
-        // Handle special values first
-        if (isNan() || decimal.isNan()) {
-            // NaN is not comparable, but we need to provide a consistent ordering
-            if (isNan() && decimal.isNan()) {
-                return 0;
-            }
-            if (isNan()) {
-                return 1; // NaN is considered greater than any other value
-            }
-            return -1;
-        }
-
-        if (isInf() && decimal.isInf()) {
-            return 0;
-        }
-        if (isInf()) {
-            return 1; // Positive infinity is greater than any finite value
-        }
-        if (decimal.isInf()) {
-            return -1;
-        }
-
-        if (isNegativeInf() && decimal.isNegativeInf()) {
-            return 0;
-        }
-        if (isNegativeInf()) {
-            return -1; // Negative infinity is less than any finite value
-        }
-
-        if (decimal.isNegativeInf()) {
-            return 1;
-        }
-
-        // Compare finite values
-        if (isNegative() != decimal.isNegative()) {
-            return isNegative() ? -1 : 1;
-        }
-
-        // Both have the same sign, compare magnitudes
-        int highComparison = Long.compareUnsigned(high, decimal.high);
-        if (highComparison != 0) {
-            return isNegative() ? -highComparison : highComparison;
+        // Fast way to compare decimals with the same scale or with special values
+        boolean isSpecial = isNan() || isInf() || isNegativeInf();
+        boolean otherIsSpecial = decimal.isNan() || decimal.isInf() || decimal.isNegativeInf();
+        if (isSpecial || otherIsSpecial || (getType().getScale() == decimal.getType().getScale())) {
+            return high != decimal.high ? Long.compare(high, decimal.high) : Long.compare(low, decimal.low);
         }
 
-        int lowComparison = Long.compareUnsigned(low, decimal.low);
-        return isNegative() ? -lowComparison : lowComparison;
+        return toBigDecimal().compareTo(decimal.toBigDecimal());
     }
 
     /**

table/src/main/java/tech/ydb/table/values/NullValue.java

@@ -47,11 +47,11 @@ public int compareTo(Value<?> other) {
             return compareTo(optional.get());
         }
 
-        if (!getType().equals(other.getType())) {
-            throw new IllegalArgumentException("Cannot compare value " + getType() + " with " + other.getType());
+        if (other instanceof VoidValue || other instanceof NullValue) {
+            // All VoidValue and NullValue  are equal
+            return 0;
         }
 
-        // All NullValue instances are equal
-        return 0;
+        throw new IllegalArgumentException("Cannot compare value " + getType() + " with " + other.getType());
     }
 }

table/src/main/java/tech/ydb/table/values/PrimitiveValue.java

@@ -20,6 +20,7 @@
 import com.google.protobuf.UnsafeByteOperations;
 
 import tech.ydb.proto.ValueProtos;
+import tech.ydb.table.utils.LittleEndian;
 import tech.ydb.table.values.proto.ProtoValue;
 
 
@@ -423,17 +424,6 @@ private static void checkType(PrimitiveType expected, PrimitiveType actual) {
         }
     }
 
-    private static int compareByteArrays(byte[] a, byte[] b) {
-        int minLength = Math.min(a.length, b.length);
-        for (int i = 0; i < minLength; i++) {
-            int comparison = Byte.compare(a[i], b[i]);
-            if (comparison != 0) {
-                return comparison;
-            }
-        }
-        return Integer.compare(a.length, b.length);
-    }
-
     @Override
     public int compareTo(Value<?> other) {
         if (other == null) {
@@ -473,22 +463,23 @@ public int compareTo(Value<?> other) {
             case Int64:
                 return Long.compare(getInt64(), otherValue.getInt64());
             case Uint64:
-                return Long.compare(getUint64(), otherValue.getUint64());
+                return Long.compareUnsigned(getUint64(), otherValue.getUint64());
             case Float:
                 return Float.compare(getFloat(), otherValue.getFloat());
             case Double:
                 return Double.compare(getDouble(), otherValue.getDouble());
             case Bytes:
+                return Arrays.compare(getBytesUnsafe(), otherValue.getBytesUnsafe());
             case Yson:
-                return compareByteArrays(getBytesUnsafe(), otherValue.getBytesUnsafe());
+                return Arrays.compare(getYsonUnsafe(), otherValue.getYsonUnsafe());
             case Text:
                 return getText().compareTo(otherValue.getText());
             case Json:
                 return getJson().compareTo(otherValue.getJson());
             case JsonDocument:
                 return getJsonDocument().compareTo(otherValue.getJsonDocument());
             case Uuid:
-                return getUuidJdk().compareTo(otherValue.getUuidJdk());
+                return compareUUID(this, otherValue);
             case Date:
                 return getDate().compareTo(otherValue.getDate());
             case Date32:
@@ -516,6 +507,16 @@ public int compareTo(Value<?> other) {
         }
     }
 
+    @SuppressWarnings("deprecation")
+    private static int compareUUID(PrimitiveValue a, PrimitiveValue b) {
+        long ah = LittleEndian.bswap(a.getUuidHigh());
+        long bh = LittleEndian.bswap(b.getUuidHigh());
+        long al = LittleEndian.bswap(a.getUuidLow());
+        long bl = LittleEndian.bswap(b.getUuidLow());
+
+        return (al != bl) ? Long.compareUnsigned(al, bl) : Long.compareUnsigned(ah, bh);
+    }
+
     // -- implementations --
 
     private static final class Bool extends PrimitiveValue {

table/src/main/java/tech/ydb/table/values/VariantValue.java

@@ -97,38 +97,6 @@ public int compareTo(Value<?> other) {
             return indexComparison;
         }
 
-        // If type indices are the same, compare the items
-        return compareValues(item, variant.item);
-    }
-
-    private static int compareValues(Value<?> a, Value<?> b) {
-        // Handle null values
-        if (a == null && b == null) {
-            return 0;
-        }
-        if (a == null) {
-            return -1;
-        }
-        if (b == null) {
-            return 1;
-        }
-
-        // Check that the types are the same
-        if (!a.getType().equals(b.getType())) {
-            throw new IllegalArgumentException("Cannot compare values of different types: " +
-                a.getType() + " vs " + b.getType());
-        }
-
-        // Use the actual compareTo method of the values
-        if (a instanceof Comparable && b instanceof Comparable) {
-            try {
-                return ((Comparable<Value<?>>) a).compareTo((Value<?>) b);
-            } catch (ClassCastException e) {
-                // Fall back to error
-            }
-        }
-
-        throw new IllegalArgumentException("Cannot compare values of different types: " +
-            a.getClass().getSimpleName() + " vs " + b.getClass().getSimpleName());
+        return item.compareTo(variant.item);
     }
 }

table/src/main/java/tech/ydb/table/values/VoidValue.java

@@ -47,11 +47,11 @@ public int compareTo(Value<?> other) {
             return compareTo(optional.get());
         }
 
-        if (!getType().equals(other.getType())) {
-            throw new IllegalArgumentException("Cannot compare value " + getType() + " with " + other.getType());
+        if (other instanceof VoidValue || other instanceof NullValue) {
+            // All VoidValue and NullValue  are equal
+            return 0;
         }
 
-        // All VoidValue instances are equal
-        return 0;
+        throw new IllegalArgumentException("Cannot compare value " + getType() + " with " + other.getType());
     }
 }