[CALCITE-7639] Use a single long shift-amount overload for the shift functions

Address review feedback on the inconsistent shift-amount overloads: the
int-valued shift methods had both an int and a long shift-amount variant,
while the long and unsigned variants only had an int shift amount, and no
(long, long) overload existed at all (so an executed BIGINT >> BIGINT would
fail to resolve at code generation).

Make every leftShift/rightShift overload take a long shift amount. An int
shift amount widens to long automatically during enumerable code generation,
so a single amount type suffices for every value type; the redundant
int-valued long-amount overloads are removed. Behaviour is unchanged at the
SQL level (the result type still follows the first argument).

  * SqlFunctions: change the shift amount of every leftShift/rightShift
    overload from int to long, and drop the now-redundant
    leftShift(int, long) / rightShift(int, long) overloads.
  * BuiltInMethod: point LEFT_SHIFT/RIGHT_SHIFT at the (int, long) overloads.
  * SqlOperatorTest: add executed BIGINT-by-BIGINT cases for both the
    operator and function forms of left and right shift.

Author: nielspardon

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

@@ -3779,7 +3779,7 @@ private static ByteString binaryOperator(
    * @param y the shift amount (positive: left shift, negative: right shift)
    * @return the shifted integer
    */
-  public static int leftShift(int x, int y) {
+  public static int leftShift(int x, long y) {
     int shift = Math.floorMod(y, 32); // normalize to 0~31
     return y >= 0 ? x << shift : x >> shift; // arithmetic right shift
   }
@@ -3793,23 +3793,11 @@ public static int leftShift(int x, int y) {
    * @param y the shift amount
    * @return the shifted long value
    */
-  public static long leftShift(long x, int y) {
+  public static long leftShift(long x, long y) {
     int shift = Math.floorMod(y, 64); // normalize to 0~63
     return y >= 0 ? x << shift : x >> shift;
   }
 
-  /**
-   * Performs PostgresSQL-style bitwise shift on an int value with a long shift amount.
-   *
-   * @param x the int value to shift
-   * @param y the long shift amount
-   * @return the shifted value as long
-   */
-  public static long leftShift(int x, long y) {
-    int shift = Math.floorMod(y, 32); // normalize to 0~31
-    return y >= 0 ? (long) x << shift : (long) x >> shift;
-  }
-
   /**
    * Performs PostgresSQL-style bitwise shift on a byte array.
    * Positive shift: left shift.
@@ -3819,7 +3807,7 @@ public static long leftShift(int x, long y) {
    * @param y the shift amount in bits
    * @return the shifted byte array
    */
-  public static byte[] leftShift(byte[] bytes, int y) {
+  public static byte[] leftShift(byte[] bytes, long y) {
     if (bytes.length == 0) {
       return new byte[0];
     }
@@ -3866,15 +3854,15 @@ public static byte[] leftShift(byte[] bytes, int y) {
    * @param y the shift amount in bits
    * @return shifted ByteString
    */
-  public static ByteString leftShift(ByteString bytes, int y) {
+  public static ByteString leftShift(ByteString bytes, long y) {
     return new ByteString(leftShift(bytes.getBytes(), y));
   }
 
   /**
    * Performs PostgresSQL-style bitwise shift on UByte.
    * Overflow bits are masked to 8 bits.
    */
-  public static UByte leftShift(UByte x, int y) {
+  public static UByte leftShift(UByte x, long y) {
     int shift = Math.floorMod(y, 8);
     int val = x.byteValue() & 0xFF;
     val = (y >= 0) ? (val << shift) & 0xFF : (val >> shift) & 0xFF;
@@ -3885,7 +3873,7 @@ public static UByte leftShift(UByte x, int y) {
    * Performs PostgresSQL-style bitwise shift on UShort.
    * Overflow bits are masked to 16 bits.
    */
-  public static UShort leftShift(UShort x, int y) {
+  public static UShort leftShift(UShort x, long y) {
     int shift = Math.floorMod(y, 16);
     int val = x.shortValue() & 0xFFFF;
     val = (y >= 0) ? (val << shift) & 0xFFFF : (val >> shift) & 0xFFFF;
@@ -3896,7 +3884,7 @@ public static UShort leftShift(UShort x, int y) {
    * Performs PostgresSQL-style bitwise shift on UInteger.
    * Overflow bits are masked to 32 bits.
    */
-  public static UInteger leftShift(UInteger x, int y) {
+  public static UInteger leftShift(UInteger x, long y) {
     int shift = Math.floorMod(y, 32);
     long val = x.longValue() & 0xFFFFFFFFL;
     val = (y >= 0) ? (val << shift) & 0xFFFFFFFFL : (val >> shift) & 0xFFFFFFFFL;
@@ -3907,7 +3895,7 @@ public static UInteger leftShift(UInteger x, int y) {
    * Performs PostgresSQL-style bitwise shift on ULong.
    * Overflow bits are masked to 64 bits (long shifts naturally truncate).
    */
-  public static ULong leftShift(ULong x, int y) {
+  public static ULong leftShift(ULong x, long y) {
     int shift = Math.floorMod(y, 64);
     long val = x.longValue();
     val = (y >= 0) ? val << shift : val >> shift;
@@ -3921,7 +3909,7 @@ public static ULong leftShift(ULong x, int y) {
    * @param y the shift amount (positive: right shift, negative: left shift)
    * @return the shifted integer
    */
-  public static int rightShift(int x, int y) {
+  public static int rightShift(int x, long y) {
     int shift = Math.floorMod(y, 32); // normalize to 0~31
     return y >= 0 ? x >> shift : x << shift; // arithmetic right shift
   }
@@ -3935,23 +3923,11 @@ public static int rightShift(int x, int y) {
    * @param y the shift amount
    * @return the shifted long value
    */
-  public static long rightShift(long x, int y) {
+  public static long rightShift(long x, long y) {
     int shift = Math.floorMod(y, 64); // normalize to 0~63
     return y >= 0 ? x >> shift : x << shift;
   }
 
-  /**
-   * Performs PostgresSQL-style bitwise shift on an int value with a long shift amount.
-   *
-   * @param x the int value to shift
-   * @param y the long shift amount
-   * @return the shifted value as long
-   */
-  public static long rightShift(int x, long y) {
-    int shift = Math.floorMod(y, 32); // normalize to 0~31
-    return y >= 0 ? (long) x >> shift : (long) x << shift;
-  }
-
   /**
    * Performs PostgresSQL-style bitwise shift on a byte array.
    * Positive shift: right shift.
@@ -3961,7 +3937,7 @@ public static long rightShift(int x, long y) {
    * @param y the shift amount in bits
    * @return the shifted byte array
    */
-  public static byte[] rightShift(byte[] bytes, int y) {
+  public static byte[] rightShift(byte[] bytes, long y) {
     if (bytes.length == 0) {
       return new byte[0];
     }
@@ -4008,15 +3984,15 @@ public static byte[] rightShift(byte[] bytes, int y) {
    * @param y the shift amount in bits
    * @return shifted ByteString
    */
-  public static ByteString rightShift(ByteString bytes, int y) {
+  public static ByteString rightShift(ByteString bytes, long y) {
     return new ByteString(rightShift(bytes.getBytes(), y));
   }
 
   /**
    * Performs PostgresSQL-style bitwise shift on UByte.
    * Overflow bits are masked to 8 bits.
    */
-  public static UByte rightShift(UByte x, int y) {
+  public static UByte rightShift(UByte x, long y) {
     int shift = Math.floorMod(y, 8);
     int val = x.byteValue() & 0xFF;
     val = (y >= 0) ? (val >> shift) & 0xFF : (val << shift) & 0xFF;
@@ -4027,7 +4003,7 @@ public static UByte rightShift(UByte x, int y) {
    * Performs PostgresSQL-style bitwise shift on UShort.
    * Overflow bits are masked to 16 bits.
    */
-  public static UShort rightShift(UShort x, int y) {
+  public static UShort rightShift(UShort x, long y) {
     int shift = Math.floorMod(y, 16);
     int val = x.shortValue() & 0xFFFF;
     val = (y >= 0) ? (val >> shift) & 0xFFFF : (val << shift) & 0xFFFF;
@@ -4038,7 +4014,7 @@ public static UShort rightShift(UShort x, int y) {
    * Performs PostgresSQL-style bitwise shift on UInteger.
    * Overflow bits are masked to 32 bits.
    */
-  public static UInteger rightShift(UInteger x, int y) {
+  public static UInteger rightShift(UInteger x, long y) {
     int shift = Math.floorMod(y, 32);
     long val = x.longValue() & 0xFFFFFFFFL;
     val = (y >= 0) ? (val >> shift) & 0xFFFFFFFFL : (val << shift) & 0xFFFFFFFFL;
@@ -4049,7 +4025,7 @@ public static UInteger rightShift(UInteger x, int y) {
    * Performs PostgresSQL-style bitwise shift on ULong.
    * Overflow bits are masked to 64 bits (long shifts naturally truncate).
    */
-  public static ULong rightShift(ULong x, int y) {
+  public static ULong rightShift(ULong x, long y) {
     int shift = Math.floorMod(y, 64);
     long val = x.longValue();
     val = (y >= 0) ? val >> shift : val << shift;

core/src/main/java/org/apache/calcite/util/BuiltInMethod.java

@@ -705,8 +705,8 @@ public enum BuiltInMethod {
   BIT_OR(SqlFunctions.class, "bitOr", long.class, long.class),
   BIT_XOR(SqlFunctions.class, "bitXor", long.class, long.class),
   BIT_NOT(SqlFunctions.class, "bitNot", long.class),
-  LEFT_SHIFT(SqlFunctions.class, "leftShift", int.class, int.class),
-  RIGHT_SHIFT(SqlFunctions.class, "rightShift", int.class, int.class),
+  LEFT_SHIFT(SqlFunctions.class, "leftShift", int.class, long.class),
+  RIGHT_SHIFT(SqlFunctions.class, "rightShift", int.class, long.class),
   MODIFIABLE_TABLE_GET_MODIFIABLE_COLLECTION(ModifiableTable.class,
       "getModifiableCollection"),
   SCANNABLE_TABLE_SCAN(ScannableTable.class, "scan", DataContext.class),

testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java

@@ -16958,6 +16958,7 @@ private static void checkLogicalOrFunc(SqlOperatorFixture f) {
     f.checkType("CAST(2 AS SMALLINT) << CAST(3 AS SMALLINT)", "SMALLINT NOT NULL");
     f.checkType("CAST(2 AS INTEGER) << CAST(3 AS INTEGER)", "INTEGER NOT NULL");
     f.checkType("CAST(2 AS BIGINT) << CAST(3 AS BIGINT)", "BIGINT NOT NULL");
+    f.checkScalar("CAST(2 AS BIGINT) << CAST(3 AS BIGINT)", "16", "BIGINT NOT NULL");
 
     // === BigInt shifts with explicit BIGINT inputs ===
     f.checkScalar("CAST(1 AS BIGINT) << 62", BigInteger.ONE.shiftLeft(62).toString(),
@@ -17078,6 +17079,7 @@ private static void checkLogicalOrFunc(SqlOperatorFixture f) {
     f.checkType("LEFTSHIFT(CAST(2 AS SMALLINT), CAST(3 AS SMALLINT))", "SMALLINT NOT NULL");
     f.checkType("LEFTSHIFT(CAST(2 AS INTEGER), CAST(3 AS INTEGER))", "INTEGER NOT NULL");
     f.checkType("LEFTSHIFT(CAST(2 AS BIGINT), CAST(3 AS BIGINT))", "BIGINT NOT NULL");
+    f.checkScalar("LEFTSHIFT(CAST(2 AS BIGINT), CAST(3 AS BIGINT))", "16", "BIGINT NOT NULL");
 
     // === BigInt shifts with explicit BIGINT inputs ===
     f.checkScalar("LEFTSHIFT(CAST(1 AS BIGINT), 62)",
@@ -17183,6 +17185,7 @@ private static void checkLogicalOrFunc(SqlOperatorFixture f) {
     f.checkType("CAST(8 AS SMALLINT) >> CAST(2 AS SMALLINT)", "SMALLINT NOT NULL");
     f.checkType("CAST(8 AS INTEGER) >> CAST(2 AS INTEGER)", "INTEGER NOT NULL");
     f.checkType("CAST(8 AS BIGINT) >> CAST(2 AS BIGINT)", "BIGINT NOT NULL");
+    f.checkScalar("CAST(8 AS BIGINT) >> CAST(2 AS BIGINT)", "2", "BIGINT NOT NULL");
 
     // === BigInt shifts with explicit BIGINT inputs (arithmetic/sign-preserving) ===
     f.checkScalar("CAST(4611686018427387904 AS BIGINT) >> 62", "1", "BIGINT NOT NULL"); // 2^62
@@ -17276,6 +17279,7 @@ private static void checkLogicalOrFunc(SqlOperatorFixture f) {
     f.checkType("RIGHTSHIFT(CAST(8 AS SMALLINT), CAST(2 AS SMALLINT))", "SMALLINT NOT NULL");
     f.checkType("RIGHTSHIFT(CAST(8 AS INTEGER), CAST(2 AS INTEGER))", "INTEGER NOT NULL");
     f.checkType("RIGHTSHIFT(CAST(8 AS BIGINT), CAST(2 AS BIGINT))", "BIGINT NOT NULL");
+    f.checkScalar("RIGHTSHIFT(CAST(8 AS BIGINT), CAST(2 AS BIGINT))", "2", "BIGINT NOT NULL");
 
     // === BigInt shifts with explicit BIGINT inputs ===
     f.checkScalar("RIGHTSHIFT(CAST(4611686018427387904 AS BIGINT), 62)", "1", "BIGINT NOT NULL");