Firestore: use Integer.compare() and Long.compare() instead Firestore bespoke implementations (#7109)

dconeybe · web-flow · commit 1b0a574e2ef5 · 2025-07-07T15:06:18.000-04:00
diff --git a/firebase-firestore/CHANGELOG.md b/firebase-firestore/CHANGELOG.md
@@ -2,6 +2,9 @@
 * [fixed] Further improved performance of UTF-8 string ordering logic,
   which had degraded in v25.1.2 and received some improvements in v25.1.3.
   [#7053](//github.com/firebase/firebase-android-sdk/issues/7053)
+* [changed] Use the `compare()` methods defined in standard `Integer`, `Long`, and `Character`
+  classes instead of Firestore's bespoke implementations.
+  [#7109](//github.com/firebase/firebase-android-sdk/pull/7109)
 
 
 # 25.1.4
diff --git a/firebase-firestore/src/main/java/com/google/cloud/datastore/core/number/NumberComparisonHelper.java b/firebase-firestore/src/main/java/com/google/cloud/datastore/core/number/NumberComparisonHelper.java
@@ -50,7 +50,7 @@ public static int firestoreCompareDoubleWithLong(double doubleValue, long longVa
     }
 
     long doubleAsLong = (long) doubleValue;
-    int cmp = compareLongs(doubleAsLong, longValue);
+    int cmp = Long.compare(doubleAsLong, longValue);
     if (cmp != 0) {
       return cmp;
     }
@@ -60,11 +60,6 @@ public static int firestoreCompareDoubleWithLong(double doubleValue, long longVa
     return firestoreCompareDoubles(doubleValue, longAsDouble);
   }
 
-  /** Compares longs. */
-  public static int compareLongs(long leftLong, long rightLong) {
-    return Long.compare(leftLong, rightLong);
-  }
-
   /**
    * Compares doubles with Firestore query semantics: NaN precedes all other numbers and equals
    * itself, all zeroes are equal.
diff --git a/firebase-firestore/src/main/java/com/google/firebase/firestore/core/View.java b/firebase-firestore/src/main/java/com/google/firebase/firestore/core/View.java
@@ -17,7 +17,6 @@
 import static com.google.firebase.firestore.core.Query.LimitType.LIMIT_TO_FIRST;
 import static com.google.firebase.firestore.core.Query.LimitType.LIMIT_TO_LAST;
 import static com.google.firebase.firestore.util.Assert.hardAssert;
-import static com.google.firebase.firestore.util.Util.compareIntegers;
 
 import androidx.annotation.Nullable;
 import com.google.firebase.database.collection.ImmutableSortedMap;
@@ -301,7 +300,7 @@ public ViewChange applyChanges(
     Collections.sort(
         viewChanges,
         (DocumentViewChange o1, DocumentViewChange o2) -> {
-          int typeComp = compareIntegers(View.changeTypeOrder(o1), View.changeTypeOrder(o2));
+          int typeComp = Integer.compare(View.changeTypeOrder(o1), View.changeTypeOrder(o2));
           if (typeComp != 0) {
             return typeComp;
           }
diff --git a/firebase-firestore/src/main/java/com/google/firebase/firestore/local/DocumentReference.java b/firebase-firestore/src/main/java/com/google/firebase/firestore/local/DocumentReference.java
@@ -14,8 +14,6 @@
 
 package com.google.firebase.firestore.local;
 
-import static com.google.firebase.firestore.util.Util.compareIntegers;
-
 import com.google.firebase.firestore.model.DocumentKey;
 import java.util.Comparator;
 
@@ -60,12 +58,12 @@ int getId() {
           return keyComp;
         }
 
-        return compareIntegers(o1.targetOrBatchId, o2.targetOrBatchId);
+        return Integer.compare(o1.targetOrBatchId, o2.targetOrBatchId);
       };
 
   static final Comparator<DocumentReference> BY_TARGET =
       (o1, o2) -> {
-        int targetComp = compareIntegers(o1.targetOrBatchId, o2.targetOrBatchId);
+        int targetComp = Integer.compare(o1.targetOrBatchId, o2.targetOrBatchId);
 
         if (targetComp != 0) {
           return targetComp;
diff --git a/firebase-firestore/src/main/java/com/google/firebase/firestore/local/SQLiteMutationQueue.java b/firebase-firestore/src/main/java/com/google/firebase/firestore/local/SQLiteMutationQueue.java
@@ -30,7 +30,6 @@
 import com.google.firebase.firestore.model.mutation.MutationBatch;
 import com.google.firebase.firestore.remote.WriteStream;
 import com.google.firebase.firestore.util.Consumer;
-import com.google.firebase.firestore.util.Util;
 import com.google.protobuf.ByteString;
 import com.google.protobuf.InvalidProtocolBufferException;
 import com.google.protobuf.MessageLite;
@@ -324,7 +323,7 @@ public List<MutationBatch> getAllMutationBatchesAffectingDocumentKeys(
       Collections.sort(
           result,
           (MutationBatch lhs, MutationBatch rhs) ->
-              Util.compareIntegers(lhs.getBatchId(), rhs.getBatchId()));
+              Integer.compare(lhs.getBatchId(), rhs.getBatchId()));
     }
     return result;
   }
diff --git a/firebase-firestore/src/main/java/com/google/firebase/firestore/model/BasePath.java b/firebase-firestore/src/main/java/com/google/firebase/firestore/model/BasePath.java
@@ -100,7 +100,7 @@ public int compareTo(@NonNull B o) {
       }
       i++;
     }
-    return Util.compareIntegers(myLength, theirLength);
+    return Integer.compare(myLength, theirLength);
   }
 
   private static int compareSegments(String lhs, String rhs) {
diff --git a/firebase-firestore/src/main/java/com/google/firebase/firestore/model/Values.java b/firebase-firestore/src/main/java/com/google/firebase/firestore/model/Values.java
@@ -214,7 +214,7 @@ public static int compare(Value left, Value right) {
     int rightType = typeOrder(right);
 
     if (leftType != rightType) {
-      return Util.compareIntegers(leftType, rightType);
+      return Integer.compare(leftType, rightType);
     }
 
     switch (leftType) {
@@ -291,7 +291,7 @@ private static int compareNumbers(Value left, Value right) {
     } else if (left.getValueTypeCase() == Value.ValueTypeCase.INTEGER_VALUE) {
       long leftLong = left.getIntegerValue();
       if (right.getValueTypeCase() == Value.ValueTypeCase.INTEGER_VALUE) {
-        return Util.compareLongs(leftLong, right.getIntegerValue());
+        return Long.compare(leftLong, right.getIntegerValue());
       } else if (right.getValueTypeCase() == Value.ValueTypeCase.DOUBLE_VALUE) {
         return -1 * Util.compareMixed(right.getDoubleValue(), leftLong);
       }
@@ -301,11 +301,11 @@ private static int compareNumbers(Value left, Value right) {
   }
 
   private static int compareTimestamps(Timestamp left, Timestamp right) {
-    int cmp = Util.compareLongs(left.getSeconds(), right.getSeconds());
+    int cmp = Long.compare(left.getSeconds(), right.getSeconds());
     if (cmp != 0) {
       return cmp;
     }
-    return Util.compareIntegers(left.getNanos(), right.getNanos());
+    return Integer.compare(left.getNanos(), right.getNanos());
   }
 
   private static int compareReferences(String leftPath, String rightPath) {
@@ -319,7 +319,7 @@ private static int compareReferences(String leftPath, String rightPath) {
         return cmp;
       }
     }
-    return Util.compareIntegers(leftSegments.length, rightSegments.length);
+    return Integer.compare(leftSegments.length, rightSegments.length);
   }
 
   private static int compareGeoPoints(LatLng left, LatLng right) {
@@ -338,7 +338,7 @@ private static int compareArrays(ArrayValue left, ArrayValue right) {
         return cmp;
       }
     }
-    return Util.compareIntegers(left.getValuesCount(), right.getValuesCount());
+    return Integer.compare(left.getValuesCount(), right.getValuesCount());
   }
 
   private static int compareMaps(MapValue left, MapValue right) {
@@ -372,7 +372,7 @@ private static int compareVectors(MapValue left, MapValue right) {
     ArrayValue rightArrayValue = rightMap.get(Values.VECTOR_MAP_VECTORS_KEY).getArrayValue();
 
     int lengthCompare =
-        Util.compareIntegers(leftArrayValue.getValuesCount(), rightArrayValue.getValuesCount());
+        Integer.compare(leftArrayValue.getValuesCount(), rightArrayValue.getValuesCount());
     if (lengthCompare != 0) {
       return lengthCompare;
     }
diff --git a/firebase-firestore/src/main/java/com/google/firebase/firestore/util/Util.java b/firebase-firestore/src/main/java/com/google/firebase/firestore/util/Util.java
@@ -73,20 +73,6 @@ public static int compareBooleans(boolean b1, boolean b2) {
     }
   }
 
-  /**
-   * Utility function to compare integers. Note that we can't use Integer.compare because it's only
-   * available after Android 19.
-   */
-  public static int compareIntegers(int i1, int i2) {
-    if (i1 < i2) {
-      return -1;
-    } else if (i1 > i2) {
-      return 1;
-    } else {
-      return 0;
-    }
-  }
-
   /** Compare strings in UTF-8 encoded byte order */
   public static int compareUtf8Strings(String left, String right) {
     // noinspection StringEquality
@@ -119,7 +105,7 @@ public static int compareUtf8Strings(String left, String right) {
       final char rightChar = right.charAt(i);
       if (leftChar != rightChar) {
         return (isSurrogate(leftChar) == isSurrogate(rightChar))
-            ? Util.compareIntegers(leftChar, rightChar)
+            ? Character.compare(leftChar, rightChar)
             : isSurrogate(leftChar) ? 1 : -1;
       }
     }
@@ -129,14 +115,6 @@ public static int compareUtf8Strings(String left, String right) {
     return Integer.compare(left.length(), right.length());
   }
 
-  /**
-   * Utility function to compare longs. Note that we can't use Long.compare because it's only
-   * available after Android 19.
-   */
-  public static int compareLongs(long i1, long i2) {
-    return NumberComparisonHelper.compareLongs(i1, i2);
-  }
-
   /** Utility function to compare doubles (using Firestore semantics for NaN). */
   public static int compareDoubles(double i1, double i2) {
     return NumberComparisonHelper.firestoreCompareDoubles(i1, i2);
@@ -274,7 +252,7 @@ public static int compareByteArrays(byte[] left, byte[] right) {
       }
       // Byte values are equal, continue with comparison
     }
-    return Util.compareIntegers(left.length, right.length);
+    return Integer.compare(left.length, right.length);
   }
 
   public static int compareByteStrings(ByteString left, ByteString right) {
@@ -290,7 +268,7 @@ public static int compareByteStrings(ByteString left, ByteString right) {
       }
       // Byte values are equal, continue with comparison
     }
-    return Util.compareIntegers(left.size(), right.size());
+    return Integer.compare(left.size(), right.size());
   }
 
   public static StringBuilder repeatSequence(
diff --git a/firebase-firestore/src/test/java/com/google/firebase/firestore/util/UtilTest.java b/firebase-firestore/src/test/java/com/google/firebase/firestore/util/UtilTest.java
@@ -108,7 +108,7 @@ public void compareUtf8StringsShouldReturnCorrectValue() {
       ByteString b2 = ByteString.copyFromUtf8(s2);
       int expected = Util.compareByteStrings(b1, b2);
 
-      if (actual == expected) {
+      if (Integer.signum(actual) == Integer.signum(expected)) {
         passCount++;
       } else {
         errors.add(
@@ -117,9 +117,12 @@ public void compareUtf8StringsShouldReturnCorrectValue() {
                 + "\", s2=\""
                 + s2
                 + "\") returned "
+                + signName(actual)
+                + " ("
                 + actual
+                + ")"
                 + ", but expected "
-                + expected
+                + signName(expected)
                 + " (i="
                 + i
                 + ", s1.length="
@@ -142,6 +145,16 @@ public void compareUtf8StringsShouldReturnCorrectValue() {
     }
   }
 
+  private static String signName(int value) {
+    if (value < 0) {
+      return "a negative value";
+    } else if (value > 0) {
+      return "a positive value";
+    } else {
+      return "0";
+    }
+  }
+
   private static class StringPairGenerator {
 
     private final StringGenerator stringGenerator;

Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ public static int firestoreCompareDoubleWithLong(double doubleValue, long longVa`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`long doubleAsLong = (long) doubleValue;`
`53`		`- int cmp = compareLongs(doubleAsLong, longValue);`
	`53`	`+ int cmp = Long.compare(doubleAsLong, longValue);`
`54`	`54`	`if (cmp != 0) {`
`55`	`55`	`return cmp;`
`56`	`56`	`}`
`@@ -60,11 +60,6 @@ public static int firestoreCompareDoubleWithLong(double doubleValue, long longVa`
`60`	`60`	`return firestoreCompareDoubles(doubleValue, longAsDouble);`
`61`	`61`	`}`
`62`	`62`
`63`		`- /** Compares longs. */`
`64`		`- public static int compareLongs(long leftLong, long rightLong) {`
`65`		`- return Long.compare(leftLong, rightLong);`
`66`		`- }`
`67`		`-`
`68`	`63`	`/**`
`69`	`64`	`* Compares doubles with Firestore query semantics: NaN precedes all other numbers and equals`
`70`	`65`	`* itself, all zeroes are equal.`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ public int compareTo(@NonNull B o) {`
`100`	`100`	`}`
`101`	`101`	`i++;`
`102`	`102`	`}`
`103`		`- return Util.compareIntegers(myLength, theirLength);`
	`103`	`+ return Integer.compare(myLength, theirLength);`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`private static int compareSegments(String lhs, String rhs) {`
Original file line number	Diff line number	Diff line change
`@@ -214,7 +214,7 @@ public static int compare(Value left, Value right) {`
`214`	`214`	`int rightType = typeOrder(right);`
`215`	`215`
`216`	`216`	`if (leftType != rightType) {`
`217`		`- return Util.compareIntegers(leftType, rightType);`
	`217`	`+ return Integer.compare(leftType, rightType);`
`218`	`218`	`}`
`219`	`219`
`220`	`220`	`switch (leftType) {`
`@@ -291,7 +291,7 @@ private static int compareNumbers(Value left, Value right) {`
`291`	`291`	`} else if (left.getValueTypeCase() == Value.ValueTypeCase.INTEGER_VALUE) {`
`292`	`292`	`long leftLong = left.getIntegerValue();`
`293`	`293`	`if (right.getValueTypeCase() == Value.ValueTypeCase.INTEGER_VALUE) {`
`294`		`- return Util.compareLongs(leftLong, right.getIntegerValue());`
	`294`	`+ return Long.compare(leftLong, right.getIntegerValue());`
`295`	`295`	`} else if (right.getValueTypeCase() == Value.ValueTypeCase.DOUBLE_VALUE) {`
`296`	`296`	`return -1 * Util.compareMixed(right.getDoubleValue(), leftLong);`
`297`	`297`	`}`
`@@ -301,11 +301,11 @@ private static int compareNumbers(Value left, Value right) {`
`301`	`301`	`}`
`302`	`302`
`303`	`303`	`private static int compareTimestamps(Timestamp left, Timestamp right) {`
`304`		`- int cmp = Util.compareLongs(left.getSeconds(), right.getSeconds());`
	`304`	`+ int cmp = Long.compare(left.getSeconds(), right.getSeconds());`
`305`	`305`	`if (cmp != 0) {`
`306`	`306`	`return cmp;`
`307`	`307`	`}`
`308`		`- return Util.compareIntegers(left.getNanos(), right.getNanos());`
	`308`	`+ return Integer.compare(left.getNanos(), right.getNanos());`
`309`	`309`	`}`
`310`	`310`
`311`	`311`	`private static int compareReferences(String leftPath, String rightPath) {`
`@@ -319,7 +319,7 @@ private static int compareReferences(String leftPath, String rightPath) {`
`319`	`319`	`return cmp;`
`320`	`320`	`}`
`321`	`321`	`}`
`322`		`- return Util.compareIntegers(leftSegments.length, rightSegments.length);`
	`322`	`+ return Integer.compare(leftSegments.length, rightSegments.length);`
`323`	`323`	`}`
`324`	`324`
`325`	`325`	`private static int compareGeoPoints(LatLng left, LatLng right) {`
`@@ -338,7 +338,7 @@ private static int compareArrays(ArrayValue left, ArrayValue right) {`
`338`	`338`	`return cmp;`
`339`	`339`	`}`
`340`	`340`	`}`
`341`		`- return Util.compareIntegers(left.getValuesCount(), right.getValuesCount());`
	`341`	`+ return Integer.compare(left.getValuesCount(), right.getValuesCount());`
`342`	`342`	`}`
`343`	`343`
`344`	`344`	`private static int compareMaps(MapValue left, MapValue right) {`
`@@ -372,7 +372,7 @@ private static int compareVectors(MapValue left, MapValue right) {`
`372`	`372`	`ArrayValue rightArrayValue = rightMap.get(Values.VECTOR_MAP_VECTORS_KEY).getArrayValue();`
`373`	`373`
`374`	`374`	`int lengthCompare =`
`375`		`- Util.compareIntegers(leftArrayValue.getValuesCount(), rightArrayValue.getValuesCount());`
	`375`	`+ Integer.compare(leftArrayValue.getValuesCount(), rightArrayValue.getValuesCount());`
`376`	`376`	`if (lengthCompare != 0) {`
`377`	`377`	`return lengthCompare;`
`378`	`378`	`}`
Original file line number	Diff line number	Diff line change
`@@ -73,20 +73,6 @@ public static int compareBooleans(boolean b1, boolean b2) {`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`
`76`		`- /**`
`77`		`- * Utility function to compare integers. Note that we can't use Integer.compare because it's only`
`78`		`- * available after Android 19.`
`79`		`- */`
`80`		`- public static int compareIntegers(int i1, int i2) {`
`81`		`- if (i1 < i2) {`
`82`		`- return -1;`
`83`		`- } else if (i1 > i2) {`
`84`		`- return 1;`
`85`		`- } else {`
`86`		`- return 0;`
`87`		`- }`
`88`		`- }`
`89`		`-`
`90`	`76`	`/** Compare strings in UTF-8 encoded byte order */`
`91`	`77`	`public static int compareUtf8Strings(String left, String right) {`
`92`	`78`	`// noinspection StringEquality`
`@@ -119,7 +105,7 @@ public static int compareUtf8Strings(String left, String right) {`
`119`	`105`	`final char rightChar = right.charAt(i);`
`120`	`106`	`if (leftChar != rightChar) {`
`121`	`107`	`return (isSurrogate(leftChar) == isSurrogate(rightChar))`
`122`		`- ? Util.compareIntegers(leftChar, rightChar)`
	`108`	`+ ? Character.compare(leftChar, rightChar)`
`123`	`109`	`: isSurrogate(leftChar) ? 1 : -1;`
`124`	`110`	`}`
`125`	`111`	`}`
`@@ -129,14 +115,6 @@ public static int compareUtf8Strings(String left, String right) {`
`129`	`115`	`return Integer.compare(left.length(), right.length());`
`130`	`116`	`}`
`131`	`117`
`132`		`- /**`
`133`		`- * Utility function to compare longs. Note that we can't use Long.compare because it's only`
`134`		`- * available after Android 19.`
`135`		`- */`
`136`		`- public static int compareLongs(long i1, long i2) {`
`137`		`- return NumberComparisonHelper.compareLongs(i1, i2);`
`138`		`- }`
`139`		`-`
`140`	`118`	`/** Utility function to compare doubles (using Firestore semantics for NaN). */`
`141`	`119`	`public static int compareDoubles(double i1, double i2) {`
`142`	`120`	`return NumberComparisonHelper.firestoreCompareDoubles(i1, i2);`
`@@ -274,7 +252,7 @@ public static int compareByteArrays(byte[] left, byte[] right) {`
`274`	`252`	`}`
`275`	`253`	`// Byte values are equal, continue with comparison`
`276`	`254`	`}`
`277`		`- return Util.compareIntegers(left.length, right.length);`
	`255`	`+ return Integer.compare(left.length, right.length);`
`278`	`256`	`}`
`279`	`257`
`280`	`258`	`public static int compareByteStrings(ByteString left, ByteString right) {`
`@@ -290,7 +268,7 @@ public static int compareByteStrings(ByteString left, ByteString right) {`
`290`	`268`	`}`
`291`	`269`	`// Byte values are equal, continue with comparison`
`292`	`270`	`}`
`293`		`- return Util.compareIntegers(left.size(), right.size());`
	`271`	`+ return Integer.compare(left.size(), right.size());`
`294`	`272`	`}`
`295`	`273`
`296`	`274`	`public static StringBuilder repeatSequence(`