remove unsigned methods

Author: rahul2393

google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SsFormat.java

@@ -140,73 +140,39 @@ public static void appendNotNullMarkerNullOrderedLast(GrowableByteArrayOutputStr
   }
 
   /**
-   * Appends an unsigned long value in ascending (increasing) sort order.
+   * Appends a boolean value in ascending (increasing) sort order.
    *
-   * <p>This encodes a non-negative long value using variable-length encoding that preserves
-   * lexicographic ordering. The encoding uses 1-9 bytes depending on the magnitude of the value.
+   * <p>Boolean values are encoded using unsigned integer encoding where false=0 and true=1. This
+   * preserves the natural ordering where false < true.
    *
    * @param out the output stream to append to
-   * @param val the unsigned value to encode, must be in range [0, Long.MAX_VALUE]
-   * @throws IllegalArgumentException if val is negative
+   * @param value the boolean value to encode
    */
-  public static void appendUnsignedLongIncreasing(GrowableByteArrayOutputStream out, long val) {
-    if (val < 0) {
-      throw new IllegalArgumentException(
-          "Unsigned long value must be non-negative: "
-              + val
-              + ". Values requiring the upper half of unsigned 64-bit range are not supported.");
-    }
-    byte[] buf = new byte[9]; // Max 9 bytes for value payload
-    int len = 0;
-
-    long tempVal = val;
-    buf[8 - len] = (byte) ((tempVal & 0x7F) << 1); // LSB is prefix-successor bit (0)
-    tempVal >>= 7;
-    len++;
-
-    while (tempVal > 0) {
-      buf[8 - len] = (byte) (tempVal & 0xFF);
-      tempVal >>= 8;
-      len++;
-    }
-
-    out.write((byte) (IS_KEY | (TYPE_UINT_1 + len - 1)));
-    out.write(buf, 9 - len, len);
+  public static void appendBoolIncreasing(GrowableByteArrayOutputStream out, boolean value) {
+    // BOOL uses unsigned int encoding: false=0, true=1
+    // For values 0 and 1, payload is always 1 byte
+    int encoded = value ? 1 : 0;
+    out.write((byte) (IS_KEY | TYPE_UINT_1)); // Header for 1-byte unsigned int
+    out.write(
+        (byte) (encoded << 1)); // Payload: value shifted left by 1 (LSB is prefix-successor bit)
   }
 
   /**
-   * Appends an unsigned long value in descending (decreasing) sort order.
+   * Appends a boolean value in descending (decreasing) sort order.
    *
-   * <p>This encodes a non-negative long value using variable-length encoding that preserves reverse
-   * lexicographic ordering. The encoding uses 1-9 bytes depending on the magnitude of the value.
+   * <p>Boolean values are encoded using unsigned integer encoding where false=0 and true=1, then
+   * inverted for descending order. This preserves reverse ordering where true < false.
    *
    * @param out the output stream to append to
-   * @param val the unsigned value to encode, must be in range [0, Long.MAX_VALUE]
-   * @throws IllegalArgumentException if val is negative
+   * @param value the boolean value to encode
    */
-  public static void appendUnsignedLongDecreasing(GrowableByteArrayOutputStream out, long val) {
-    if (val < 0) {
-      throw new IllegalArgumentException(
-          "Unsigned long value must be non-negative: "
-              + val
-              + ". Values requiring the upper half of unsigned 64-bit range are not supported.");
-    }
-    byte[] buf = new byte[9];
-    int len = 0;
-    long tempVal = val;
-
-    buf[8 - len] = (byte) ((~(tempVal & 0x7F) & 0x7F) << 1);
-    tempVal >>= 7;
-    len++;
-
-    while (tempVal > 0) {
-      buf[8 - len] = (byte) (~(tempVal & 0xFF));
-      tempVal >>= 8;
-      len++;
-    }
-
-    out.write((byte) (IS_KEY | (TYPE_DECREASING_UINT_1 - len + 1)));
-    out.write(buf, 9 - len, len);
+  public static void appendBoolDecreasing(GrowableByteArrayOutputStream out, boolean value) {
+    // BOOL uses decreasing unsigned int encoding: false=0, true=1, then inverted
+    // For values 0 and 1, payload is always 1 byte
+    int encoded = value ? 1 : 0;
+    out.write(
+        (byte) (IS_KEY | TYPE_DECREASING_UINT_1)); // Header for 1-byte decreasing unsigned int
+    out.write((byte) ((~encoded & 0x7F) << 1)); // Inverted payload
   }
 
   private static void appendIntInternal(

google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/SsFormatTest.java

@@ -353,58 +353,61 @@ public void appendIntIncreasing_edgeCases() {
     }
   }
 
-  // ==================== Unsigned Integer Tests ====================
+  // ==================== Boolean Tests ====================
 
   @Test
-  public void appendUnsignedLongIncreasing_preservesOrdering() {
-    // Filter to only non-negative values for unsigned comparison
-    List<Long> positiveValues = new ArrayList<>();
-    for (long v : unsignedIntTestValues) {
-      if (v >= 0) positiveValues.add(v);
-    }
-    positiveValues.sort(Long::compareUnsigned);
+  public void appendBoolIncreasing_preservesOrdering() {
+    GrowableByteArrayOutputStream outFalse = new GrowableByteArrayOutputStream();
+    GrowableByteArrayOutputStream outTrue = new GrowableByteArrayOutputStream();
 
-    for (int i = 0; i < positiveValues.size() - 1; i++) {
-      long v1 = positiveValues.get(i);
-      long v2 = positiveValues.get(i + 1);
+    SsFormat.appendBoolIncreasing(outFalse, false);
+    SsFormat.appendBoolIncreasing(outTrue, true);
 
-      GrowableByteArrayOutputStream out1 = new GrowableByteArrayOutputStream();
-      GrowableByteArrayOutputStream out2 = new GrowableByteArrayOutputStream();
+    assertTrue(
+        "Encoded false should be less than encoded true",
+        UNSIGNED_BYTE_COMPARATOR.compare(outFalse.toByteArray(), outTrue.toByteArray()) < 0);
+  }
 
-      SsFormat.appendUnsignedLongIncreasing(out1, v1);
-      SsFormat.appendUnsignedLongIncreasing(out2, v2);
+  @Test
+  public void appendBoolIncreasing_encodesCorrectly() {
+    GrowableByteArrayOutputStream outFalse = new GrowableByteArrayOutputStream();
+    GrowableByteArrayOutputStream outTrue = new GrowableByteArrayOutputStream();
 
-      assertTrue(
-          "Unsigned encoded "
-              + Long.toUnsignedString(v1)
-              + " should be less than "
-              + Long.toUnsignedString(v2),
-          UNSIGNED_BYTE_COMPARATOR.compare(out1.toByteArray(), out2.toByteArray()) < 0);
-    }
+    SsFormat.appendBoolIncreasing(outFalse, false);
+    SsFormat.appendBoolIncreasing(outTrue, true);
+
+    // false=0: header 0x80 (IS_KEY | TYPE_UINT_1), payload 0x00
+    assertArrayEquals(new byte[] {(byte) 0x80, 0x00}, outFalse.toByteArray());
+    // true=1: header 0x80, payload 0x02 (1 << 1)
+    assertArrayEquals(new byte[] {(byte) 0x80, 0x02}, outTrue.toByteArray());
   }
 
   @Test
-  public void appendUnsignedLongIncreasing_rejectsNegativeValues() {
-    GrowableByteArrayOutputStream out = new GrowableByteArrayOutputStream();
-    assertThrows(
-        IllegalArgumentException.class, () -> SsFormat.appendUnsignedLongIncreasing(out, -1));
+  public void appendBoolDecreasing_reversesOrdering() {
+    GrowableByteArrayOutputStream outFalse = new GrowableByteArrayOutputStream();
+    GrowableByteArrayOutputStream outTrue = new GrowableByteArrayOutputStream();
+
+    SsFormat.appendBoolDecreasing(outFalse, false);
+    SsFormat.appendBoolDecreasing(outTrue, true);
+
+    assertTrue(
+        "Decreasing encoded false should be greater than encoded true",
+        UNSIGNED_BYTE_COMPARATOR.compare(outFalse.toByteArray(), outTrue.toByteArray()) > 0);
   }
 
   @Test
-  public void appendUnsignedLongDecreasing_reversesOrdering() {
-    long[] values = {0, 1, 100, 1000, Long.MAX_VALUE};
-
-    for (int i = 0; i < values.length - 1; i++) {
-      GrowableByteArrayOutputStream out1 = new GrowableByteArrayOutputStream();
-      GrowableByteArrayOutputStream out2 = new GrowableByteArrayOutputStream();
+  public void appendBoolDecreasing_encodesCorrectly() {
+    GrowableByteArrayOutputStream outFalse = new GrowableByteArrayOutputStream();
+    GrowableByteArrayOutputStream outTrue = new GrowableByteArrayOutputStream();
 
-      SsFormat.appendUnsignedLongDecreasing(out1, values[i]);
-      SsFormat.appendUnsignedLongDecreasing(out2, values[i + 1]);
+    SsFormat.appendBoolDecreasing(outFalse, false);
+    SsFormat.appendBoolDecreasing(outTrue, true);
 
-      assertTrue(
-          "Decreasing unsigned encoded " + values[i] + " should be greater than " + values[i + 1],
-          UNSIGNED_BYTE_COMPARATOR.compare(out1.toByteArray(), out2.toByteArray()) > 0);
-    }
+    // false=0 inverted: header 0xA8 (IS_KEY | TYPE_DECREASING_UINT_1), payload 0xFE (~0 & 0x7F) <<
+    // 1
+    assertArrayEquals(new byte[] {(byte) 0xA8, (byte) 0xFE}, outFalse.toByteArray());
+    // true=1 inverted: header 0xA8, payload 0xFC (~1 & 0x7F) << 1
+    assertArrayEquals(new byte[] {(byte) 0xA8, (byte) 0xFC}, outTrue.toByteArray());
   }
 
   // ==================== String Tests ====================