[CALCITE-7639] Normalize shift amounts with a JDK 8 compatible positiveModulo helper

An earlier commit made the shift amount a long and normalized it with
Math.floorMod(y, <int width>). Math.floorMod(long, int) was only added in
JDK 9, so on JDK 8 the call resolves to Math.floorMod(long, long) (returning
long) and does not compile when assigned to an int ('incompatible types:
possible lossy conversion from long to int').

Introduce a private positiveModulo(long, int) helper that widens to
Math.floorMod(long, long) and narrows the result (always in [0, m)) back to
int, and route all shift-amount normalizations through it. This keeps the
JDK 8 build working and factors the modulo into a single named helper.

Author: nielspardon

core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java

@@ -3772,6 +3772,21 @@ private static ByteString binaryOperator(
     return new ByteString(result);
   }
 
+  /**
+   * Returns {@code x} modulo {@code m}, normalized to the range {@code [0, m)}
+   * (unlike {@code %}, the result is never negative). Used to normalize a shift
+   * amount to the bit width of the value being shifted.
+   *
+   * @param x the value (typically a shift amount, which may be negative)
+   * @param m the modulus, which must be positive (typically a bit width)
+   * @return {@code x} modulo {@code m}, in the range {@code [0, m)}
+   */
+  private static int positiveModulo(long x, int m) {
+    // Math.floorMod(long, int) is only available since JDK 9, so widen to
+    // Math.floorMod(long, long) and narrow the result (always in [0, m)) to int.
+    return (int) Math.floorMod(x, (long) m);
+  }
+
   /**
    * Performs PostgresSQL-style bitwise shift on a 32-bit integer.
    *
@@ -3780,7 +3795,7 @@ private static ByteString binaryOperator(
    * @return the shifted integer
    */
   public static int leftShift(int x, long y) {
-    int shift = Math.floorMod(y, 32); // normalize to 0~31
+    int shift = positiveModulo(y, 32); // normalize to 0~31
     return y >= 0 ? x << shift : x >> shift; // arithmetic right shift
   }
 
@@ -3794,7 +3809,7 @@ public static int leftShift(int x, long y) {
    * @return the shifted long value
    */
   public static long leftShift(long x, long y) {
-    int shift = Math.floorMod(y, 64); // normalize to 0~63
+    int shift = positiveModulo(y, 64); // normalize to 0~63
     return y >= 0 ? x << shift : x >> shift;
   }
 
@@ -3816,7 +3831,7 @@ public static byte[] leftShift(byte[] bytes, long y) {
 
     // PostgreSQL behavior: always treat as left shift with modulo arithmetic
     // Negative y becomes equivalent positive shift
-    int shift = Math.floorMod(y, bitLen);
+    int shift = positiveModulo(y, bitLen);
 
     if (shift == 0) {
       return bytes.clone();
@@ -3863,7 +3878,7 @@ public static ByteString leftShift(ByteString bytes, long y) {
    * Overflow bits are masked to 8 bits.
    */
   public static UByte leftShift(UByte x, long y) {
-    int shift = Math.floorMod(y, 8);
+    int shift = positiveModulo(y, 8);
     int val = x.byteValue() & 0xFF;
     val = (y >= 0) ? (val << shift) & 0xFF : (val >> shift) & 0xFF;
     return UByte.valueOf((byte) val);
@@ -3874,7 +3889,7 @@ public static UByte leftShift(UByte x, long y) {
    * Overflow bits are masked to 16 bits.
    */
   public static UShort leftShift(UShort x, long y) {
-    int shift = Math.floorMod(y, 16);
+    int shift = positiveModulo(y, 16);
     int val = x.shortValue() & 0xFFFF;
     val = (y >= 0) ? (val << shift) & 0xFFFF : (val >> shift) & 0xFFFF;
     return UShort.valueOf((short) val);
@@ -3885,7 +3900,7 @@ public static UShort leftShift(UShort x, long y) {
    * Overflow bits are masked to 32 bits.
    */
   public static UInteger leftShift(UInteger x, long y) {
-    int shift = Math.floorMod(y, 32);
+    int shift = positiveModulo(y, 32);
     long val = x.longValue() & 0xFFFFFFFFL;
     val = (y >= 0) ? (val << shift) & 0xFFFFFFFFL : (val >> shift) & 0xFFFFFFFFL;
     return UInteger.valueOf(val);
@@ -3896,7 +3911,7 @@ public static UInteger leftShift(UInteger x, long y) {
    * Overflow bits are masked to 64 bits (long shifts naturally truncate).
    */
   public static ULong leftShift(ULong x, long y) {
-    int shift = Math.floorMod(y, 64);
+    int shift = positiveModulo(y, 64);
     long val = x.longValue();
     val = (y >= 0) ? val << shift : val >> shift;
     return ULong.valueOf(val);
@@ -3910,7 +3925,7 @@ public static ULong leftShift(ULong x, long y) {
    * @return the shifted integer
    */
   public static int rightShift(int x, long y) {
-    int shift = Math.floorMod(y, 32); // normalize to 0~31
+    int shift = positiveModulo(y, 32); // normalize to 0~31
     return y >= 0 ? x >> shift : x << shift; // arithmetic right shift
   }
 
@@ -3924,7 +3939,7 @@ public static int rightShift(int x, long y) {
    * @return the shifted long value
    */
   public static long rightShift(long x, long y) {
-    int shift = Math.floorMod(y, 64); // normalize to 0~63
+    int shift = positiveModulo(y, 64); // normalize to 0~63
     return y >= 0 ? x >> shift : x << shift;
   }
 
@@ -3946,7 +3961,7 @@ public static byte[] rightShift(byte[] bytes, long y) {
 
     // PostgreSQL behavior: always treat as right shift with modulo arithmetic
     // Negative y becomes equivalent positive shift
-    int shift = Math.floorMod(y, bitLen);
+    int shift = positiveModulo(y, bitLen);
 
     if (shift == 0) {
       return bytes.clone();
@@ -3993,7 +4008,7 @@ public static ByteString rightShift(ByteString bytes, long y) {
    * Overflow bits are masked to 8 bits.
    */
   public static UByte rightShift(UByte x, long y) {
-    int shift = Math.floorMod(y, 8);
+    int shift = positiveModulo(y, 8);
     int val = x.byteValue() & 0xFF;
     val = (y >= 0) ? (val >> shift) & 0xFF : (val << shift) & 0xFF;
     return UByte.valueOf((byte) val);
@@ -4004,7 +4019,7 @@ public static UByte rightShift(UByte x, long y) {
    * Overflow bits are masked to 16 bits.
    */
   public static UShort rightShift(UShort x, long y) {
-    int shift = Math.floorMod(y, 16);
+    int shift = positiveModulo(y, 16);
     int val = x.shortValue() & 0xFFFF;
     val = (y >= 0) ? (val >> shift) & 0xFFFF : (val << shift) & 0xFFFF;
     return UShort.valueOf((short) val);
@@ -4015,7 +4030,7 @@ public static UShort rightShift(UShort x, long y) {
    * Overflow bits are masked to 32 bits.
    */
   public static UInteger rightShift(UInteger x, long y) {
-    int shift = Math.floorMod(y, 32);
+    int shift = positiveModulo(y, 32);
     long val = x.longValue() & 0xFFFFFFFFL;
     val = (y >= 0) ? (val >> shift) & 0xFFFFFFFFL : (val << shift) & 0xFFFFFFFFL;
     return UInteger.valueOf(val);
@@ -4026,7 +4041,7 @@ public static UInteger rightShift(UInteger x, long y) {
    * Overflow bits are masked to 64 bits (long shifts naturally truncate).
    */
   public static ULong rightShift(ULong x, long y) {
-    int shift = Math.floorMod(y, 64);
+    int shift = positiveModulo(y, 64);
     long val = x.longValue();
     val = (y >= 0) ? val >> shift : val << shift;
     return ULong.valueOf(val);