[CALCITE-7639] Descope binary right shift pending endianness design (CALCITE-7651)

The byte[] shift added for LEFTSHIFT treats binary as little-endian and
modulo-wraps the amount, which is inconsistent with the big-endian
CAST(INT AS BINARY) from CALCITE-7368. Rather than cement that behaviour
in a new operator, restrict >> and RIGHTSHIFT to integer/unsigned operands
and reject BINARY/VARBINARY at validation. Binary shift semantics are
tracked separately in CALCITE-7651; binary left shift is left as released.

- Split the shared shift operand type checker: keep BINARY for <</LEFTSHIFT,
  add a non-binary checker for >>/RIGHTSHIFT.
- Remove the unused rightShift(byte[])/rightShift(ByteString) overloads.
- Replace the binary/VARBINARY right-shift tests with checkFails that pin
  the rejection; keep the integer/unsigned coverage.
- Update the RIGHTSHIFT reference docs accordingly.

Author: nielspardon

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

@@ -3945,65 +3945,9 @@ public static long rightShift(long x, long y) {
     return y >= 0 ? x >> shift : x << shift;
   }
 
-  /**
-   * Performs PostgresSQL-style bitwise shift on a byte array.
-   * Positive shift: right shift.
-   * Negative shift: treated as positive shift with modulo arithmetic.
-   *
-   * @param bytes the input byte array
-   * @param y the shift amount in bits
-   * @return the shifted byte array
-   */
-  public static byte[] rightShift(byte[] bytes, long y) {
-    if (bytes.length == 0) {
-      return new byte[0];
-    }
-
-    int bitLen = bytes.length * 8;
-
-    // PostgreSQL behavior: always treat as right shift with modulo arithmetic
-    // Negative y becomes equivalent positive shift
-    int shift = positiveModulo(y, bitLen);
-
-    if (shift == 0) {
-      return bytes.clone();
-    }
-
-    byte[] result = new byte[bytes.length];
-
-    // Always perform right shift (even for originally negative y)
-    int byteShift = shift / 8;
-    int bitShift = shift % 8;
-
-    for (int i = 0; i < bytes.length; i++) {
-      int srcIndex = i + byteShift;
-      int val = 0;
-
-      // Get the main byte
-      if (srcIndex < bytes.length) {
-        val = (bytes[srcIndex] & 0xFF) >>> bitShift;
-      }
-
-      // Get carry bits from next byte
-      if (srcIndex + 1 < bytes.length && bitShift != 0) {
-        val |= (bytes[srcIndex + 1] & 0xFF) << (8 - bitShift);
-      }
-
-      result[i] = (byte) val;
-    }
-    return result;
-  }
-
-  /**
-   * Performs PostgresSQL-style bitwise shift on ByteString.
-   *
-   * @param bytes the ByteString to shift
-   * @param y the shift amount in bits
-   * @return shifted ByteString
-   */
-  public static ByteString rightShift(ByteString bytes, long y) {
-    return new ByteString(rightShift(bytes.getBytes(), y));
-  }
+  // Right shift on binary (byte[]/ByteString) is intentionally not implemented:
+  // BINARY/VARBINARY operands are rejected for >> and RIGHTSHIFT until the
+  // endianness of bitwise shifts on binary is settled. See [CALCITE-7651].
 
   /**
    * Performs PostgresSQL-style bitwise shift on UByte.

core/src/main/java/org/apache/calcite/sql/fun/SqlStdOperatorTable.java

@@ -1369,16 +1369,28 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
       new SqlBitOpAggFunction(SqlKind.BIT_XOR);
 
   /**
-   * Operand type checker shared by the shift operators ({@code <<}, {@code >>})
-   * and their function forms ({@code LEFTSHIFT}, {@code RIGHTSHIFT}). The first
-   * operand is the value being shifted (integer, binary or unsigned numeric) and
-   * the second is the integer shift amount.
+   * Operand type checker shared by the left shift operator ({@code <<}) and its
+   * function form ({@code LEFTSHIFT}). The first operand is the value being
+   * shifted (integer, binary or unsigned numeric) and the second is the integer
+   * shift amount.
    */
   private static final SqlOperandTypeChecker SHIFT_OPERAND_TYPE_CHECKER =
       OperandTypes.INTEGER_INTEGER
           .or(OperandTypes.family(SqlTypeFamily.BINARY, SqlTypeFamily.INTEGER))
           .or(OperandTypes.family(SqlTypeFamily.UNSIGNED_NUMERIC, SqlTypeFamily.INTEGER));
 
+  /**
+   * Operand type checker for the right shift operator ({@code >>}) and its
+   * function form ({@code RIGHTSHIFT}). Like {@link #SHIFT_OPERAND_TYPE_CHECKER}
+   * but the value being shifted may only be integer or unsigned numeric, not
+   * binary. Binary right shift is intentionally excluded until the endianness of
+   * bitwise shifts on {@code BINARY}/{@code VARBINARY} is settled; see
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-7651">[CALCITE-7651]</a>.
+   */
+  private static final SqlOperandTypeChecker NON_BINARY_SHIFT_OPERAND_TYPE_CHECKER =
+      OperandTypes.INTEGER_INTEGER
+          .or(OperandTypes.family(SqlTypeFamily.UNSIGNED_NUMERIC, SqlTypeFamily.INTEGER));
+
   /**
    * <code>{@code <<}</code> (left shift) operator.
    */
@@ -1413,7 +1425,7 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
           true,
           ReturnTypes.ARG0_NULLABLE,
           InferTypes.FIRST_KNOWN,
-          SHIFT_OPERAND_TYPE_CHECKER);
+          NON_BINARY_SHIFT_OPERAND_TYPE_CHECKER);
 
   /**
    * right shift function.
@@ -1423,7 +1435,7 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
           "RIGHTSHIFT",
           SqlKind.OTHER_FUNCTION,
           ReturnTypes.ARG0_NULLABLE,
-          SHIFT_OPERAND_TYPE_CHECKER);
+          NON_BINARY_SHIFT_OPERAND_TYPE_CHECKER);
 
   //-------------------------------------------------------------
   // WINDOW Aggregate Functions

core/src/test/java/org/apache/calcite/test/SqlFunctionsTest.java

@@ -2080,40 +2080,9 @@ private long sqlTimestamp(String str) {
   }
 
   @Test void testRightShift() {
-    // For every shift amount, cross-check the byte-array shift against the
-    // equivalent shift computed on the value's integer interpretation. The byte
-    // array is treated as a little-endian bit string of width 8 * length (index
-    // 0 is the least-significant byte); rightShift always shifts right (zero
-    // fill) by the amount normalized modulo that width, so a negative amount
-    // wraps into range rather than reversing direction.
-    byte[] data1 = {(byte) 0xF0}; // 11110000
-    for (int shift = -10; shift <= 10; shift++) {
-      byte[] result = SqlFunctions.rightShift(data1.clone(), shift);
-      assertEquals(1, result.length);
-      int norm = Math.floorMod(shift, 8);
-      int expected = (data1[0] & 0xFF) >>> norm;
-      assertEquals((byte) expected, result[0]);
-    }
-
-    byte[] data2 = {(byte) 0x12, (byte) 0x34};
-    for (int shift = -18; shift <= 18; shift++) {
-      byte[] result = SqlFunctions.rightShift(data2.clone(), shift);
-      assertEquals(2, result.length);
-      int value = (data2[0] & 0xFF) | ((data2[1] & 0xFF) << 8); // little-endian
-      int norm = Math.floorMod(shift, 16);
-      int expected = value >>> norm;
-      assertEquals((byte) expected, result[0]);
-      assertEquals((byte) (expected >>> 8), result[1]);
-    }
-
-    // Verify specific known cases
-    assertArrayEquals(new byte[]{(byte) 0xAB, (byte) 0xCD},
-        SqlFunctions.rightShift(new byte[]{(byte) 0xAB, (byte) 0xCD}, 0));
-
-    assertArrayEquals(new byte[]{(byte) 0x40, (byte) 0x00},
-        SqlFunctions.rightShift(new byte[]{(byte) 0x80, (byte) 0x00}, 1));
-
-    // Scalar arithmetic (sign-preserving) right shift
+    // Scalar arithmetic (sign-preserving) right shift. Binary right shift is
+    // intentionally not supported (see [CALCITE-7651]), so there is no
+    // byte-array overload to exercise here.
     assertEquals(2, SqlFunctions.rightShift(8, 2));
     assertEquals(-5, SqlFunctions.rightShift(-20, 2));
   }

site/_docs/reference.md

@@ -2974,7 +2974,7 @@ In the following:
 | * | BITOR(value1, value2)                          | Returns the bitwise OR of *value1* and *value2*. *value1* and *value2* must both be integer or binary values. Binary values must be of the same length.
 | * | BITXOR(value1, value2)                         | Returns the bitwise XOR of *value1* and *value2*. *value1* and *value2* must both be integer or binary values. Binary values must be of the same length.
 | * | LEFTSHIFT(value1, value2) | Returns the result of left-shifting *value1* by *value2* bits. *value1* can be integer, unsigned integer, or binary. For binary, the result has the same length as *value1*. The shift amount *value2* is normalized using modulo arithmetic based on the bit width of *value1* (for example, modulo 32 for `INTEGER` and modulo 64 for `BIGINT`); for binary types it is modulo (8 × N), where N is the actual length in bytes of the *value1* value — for a variable-length `VARBINARY` value this is the length of the value itself, not its declared maximum. For integer and unsigned types the sign of *value2* selects the direction: a non-negative amount shifts left and a negative amount shifts right by the normalized magnitude (for example, `LEFTSHIFT(1, -2)` returns `0`, a right shift by 30, and `LEFTSHIFT(8, -1)` returns `0`). For binary the shift is always to the left; a negative *value2* is simply folded into the range [0, 8 × N) by the same modulo.
-| * | RIGHTSHIFT(value1, value2) | Returns the result of right-shifting *value1* by *value2* bits. For signed integers the shift is arithmetic (the sign bit is preserved). *value1* can be integer, unsigned integer, or binary. For binary, the result has the same length as *value1*. The shift amount *value2* is normalized using modulo arithmetic based on the bit width of *value1* (for example, modulo 32 for `INTEGER` and modulo 64 for `BIGINT`); for binary types it is modulo (8 × N), where N is the actual length in bytes of the *value1* value — for a variable-length `VARBINARY` value this is the length of the value itself, not its declared maximum. For integer and unsigned types the sign of *value2* selects the direction: a non-negative amount shifts right and a negative amount shifts left by the normalized magnitude (for example, `RIGHTSHIFT(1024, 2)` returns `256`, `RIGHTSHIFT(-20, 2)` returns `-5`, and `RIGHTSHIFT(1, -2)` returns `1073741824`, a left shift by 30). For binary the shift is always to the right; a negative *value2* is simply folded into the range [0, 8 × N) by the same modulo.
+| * | RIGHTSHIFT(value1, value2) | Returns the result of right-shifting *value1* by *value2* bits. For signed integers the shift is arithmetic (the sign bit is preserved). *value1* can be integer or unsigned integer (binary right shift is not yet supported). The shift amount *value2* is normalized using modulo arithmetic based on the bit width of *value1* (for example, modulo 32 for `INTEGER` and modulo 64 for `BIGINT`). The sign of *value2* selects the direction: a non-negative amount shifts right and a negative amount shifts left by the normalized magnitude (for example, `RIGHTSHIFT(1024, 2)` returns `256`, `RIGHTSHIFT(-20, 2)` returns `-5`, and `RIGHTSHIFT(1, -2)` returns `1073741824`, a left shift by 30).
 | * | BITNOT(value)                                  | Returns the bitwise NOT of *value*. *value* must be either an integer type or a binary value.
 | f | BITAND_AGG(value)                              | Equivalent to `BIT_AND(value)`
 | f | BITOR_AGG(value)                               | Equivalent to `BIT_OR(value)`

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

@@ -17226,7 +17226,7 @@ private static void checkLogicalOrFunc(SqlOperatorFixture f) {
     f.checkScalar("CAST(8 AS INTEGER) >> CAST(2 AS BIGINT)", "2", "INTEGER NOT NULL");
     f.checkFails("^8 >> CAST(2 AS INTEGER UNSIGNED)^",
         "Cannot apply '>>' to arguments of type '<INTEGER> >> <INTEGER UNSIGNED>'\\. "
-            + "Supported form\\(s\\): '<INTEGER> >> <INTEGER>'\\n'<BINARY> >> <INTEGER>'\\n"
+            + "Supported form\\(s\\): '<INTEGER> >> <INTEGER>'\\n"
             + "'<UNSIGNED_NUMERIC> >> <INTEGER>'",
         false);
 
@@ -17241,46 +17241,25 @@ private static void checkLogicalOrFunc(SqlOperatorFixture f) {
     f.checkScalar("0 >> 32", "0", "INTEGER NOT NULL");
     f.checkScalar("0 >> 100", "0", "INTEGER NOT NULL");
 
-    // === Binary type tests ===
-    // A binary literal such as X'FF' already has type BINARY(1) (X'FFFF' is
-    // BINARY(2), and so on), so no cast is needed to exercise the BINARY path.
-    f.checkScalar("X'FF' >> 1", "7f", "BINARY(1) NOT NULL");
-    f.checkScalar("X'F0' >> 4", "0f", "BINARY(1) NOT NULL");
-    f.checkScalar("X'08' >> 3", "01", "BINARY(1) NOT NULL");
-    f.checkScalar("X'00' >> 5", "00", "BINARY(1) NOT NULL");
-
-    f.checkScalar("X'FFFF' >> 1", "ff7f", "BINARY(2) NOT NULL");
-    f.checkScalar("X'1234' >> 4", "4103", "BINARY(2) NOT NULL");
-    f.checkScalar("X'1234' >> 8", "3400", "BINARY(2) NOT NULL");
-
-    f.checkScalar("X'FF' >> 8", "ff", "BINARY(1) NOT NULL");
-    f.checkScalar("X'FFFF' >> 16", "ffff", "BINARY(2) NOT NULL");
-
-    f.checkScalar("X'ABCD' >> 0", "abcd", "BINARY(2) NOT NULL");
-    f.checkScalar("X'123456' >> 4", "416305", "BINARY(3) NOT NULL");
-    f.checkScalar("X'0001' >> 1", "8000", "BINARY(2) NOT NULL");
-    f.checkScalar("X'8000' >> 1", "4000", "BINARY(2) NOT NULL");
-    f.checkScalar("X'F0' >> -4", "0f", "BINARY(1) NOT NULL");
-
-    // === VARBINARY type tests ===
-    // For variable-length binary the shift width is 8 * the actual value
-    // length, so the modulo used to normalize the amount tracks the value.
-    f.checkScalar("CAST(X'FF' AS VARBINARY) >> 1", "7f", "VARBINARY NOT NULL");
-    f.checkScalar("CAST(X'F0' AS VARBINARY) >> 4", "0f", "VARBINARY NOT NULL");
-    f.checkScalar("CAST(X'FFFF' AS VARBINARY) >> 1", "ff7f", "VARBINARY NOT NULL");
-    f.checkScalar("CAST(X'123456' AS VARBINARY) >> 4", "416305",
-        "VARBINARY NOT NULL");
-    // 8 % (8 * 1) = 0 leaves the 1-byte value unchanged, while 8 % (8 * 2) = 8
-    // shifts the 2-byte value by a whole byte: the width follows the value.
-    f.checkScalar("CAST(X'FF' AS VARBINARY) >> 8", "ff", "VARBINARY NOT NULL");
-    f.checkScalar("CAST(X'FFFF' AS VARBINARY) >> 8", "ff00",
-        "VARBINARY NOT NULL");
-    f.checkScalar("CAST(X'F0' AS VARBINARY) >> -4", "0f", "VARBINARY NOT NULL");
+    // === Binary operands are not supported ===
+    // Unlike '<<', binary right shift is intentionally rejected until the
+    // endianness of bitwise shifts on binary is settled (see [CALCITE-7651]).
+    // A binary literal such as X'FF' already has type BINARY(1).
+    f.checkFails("^X'FF' >> 1^",
+        "Cannot apply '>>' to arguments of type '<BINARY\\(1\\)> >> <INTEGER>'\\. "
+            + "Supported form\\(s\\): '<INTEGER> >> <INTEGER>'\\n"
+            + "'<UNSIGNED_NUMERIC> >> <INTEGER>'",
+        false);
+    f.checkFails("^CAST(X'FF' AS VARBINARY) >> 1^",
+        "Cannot apply '>>' to arguments of type '<VARBINARY> >> <INTEGER>'\\. "
+            + "Supported form\\(s\\): '<INTEGER> >> <INTEGER>'\\n"
+            + "'<UNSIGNED_NUMERIC> >> <INTEGER>'",
+        false);
 
     // === Invalid argument types ===
     f.checkFails("^1.2 >> 2^",
         "Cannot apply '>>' to arguments of type '<DECIMAL\\(2, 1\\)> >> <INTEGER>'\\. Supported "
-            + "form\\(s\\): '<INTEGER> >> <INTEGER>'\\n'<BINARY> >> <INTEGER>'\\n'<UNSIGNED_NUMERIC> "
+            + "form\\(s\\): '<INTEGER> >> <INTEGER>'\\n'<UNSIGNED_NUMERIC> "
             + ">> <INTEGER>'",
         false);
 
@@ -17347,54 +17326,26 @@ private static void checkLogicalOrFunc(SqlOperatorFixture f) {
     f.checkScalar("RIGHTSHIFT(0, 32)", "0", "INTEGER NOT NULL");
     f.checkScalar("RIGHTSHIFT(0, 100)", "0", "INTEGER NOT NULL");
 
-    // === Binary types ===
-    // A binary literal such as X'FF' already has type BINARY(1) (X'FFFF' is
-    // BINARY(2), and so on), so no cast is needed to exercise the BINARY path.
-    f.checkScalar("RIGHTSHIFT(X'FF', 1)", "7f", "BINARY(1) NOT NULL");
-    f.checkScalar("RIGHTSHIFT(X'F0', 4)", "0f", "BINARY(1) NOT NULL");
-    f.checkScalar("RIGHTSHIFT(X'08', 3)", "01", "BINARY(1) NOT NULL");
-    f.checkScalar("RIGHTSHIFT(X'00', 5)", "00", "BINARY(1) NOT NULL");
-
-    f.checkScalar("RIGHTSHIFT(X'FFFF', 1)", "ff7f", "BINARY(2) NOT NULL");
-    f.checkScalar("RIGHTSHIFT(X'1234', 4)", "4103", "BINARY(2) NOT NULL");
-    f.checkScalar("RIGHTSHIFT(X'1234', 8)", "3400", "BINARY(2) NOT NULL");
-    f.checkScalar("RIGHTSHIFT(X'FF', 8)", "ff", "BINARY(1) NOT NULL");
-    f.checkScalar("RIGHTSHIFT(X'FFFF', 16)", "ffff", "BINARY(2) NOT NULL");
-
-    f.checkScalar("RIGHTSHIFT(X'ABCD', 0)", "abcd", "BINARY(2) NOT NULL");
-    f.checkScalar("RIGHTSHIFT(X'123456', 4)", "416305", "BINARY(3) NOT NULL");
-    f.checkScalar("RIGHTSHIFT(X'0001', 1)", "8000", "BINARY(2) NOT NULL");
-    f.checkScalar("RIGHTSHIFT(X'8000', 1)", "4000", "BINARY(2) NOT NULL");
-    f.checkScalar("RIGHTSHIFT(X'F0', -4)", "0f", "BINARY(1) NOT NULL");
-
-    // === VARBINARY types ===
-    // For variable-length binary the shift width is 8 * the actual value
-    // length, so the modulo used to normalize the amount tracks the value.
-    f.checkScalar("RIGHTSHIFT(CAST(X'FF' AS VARBINARY), 1)", "7f",
-        "VARBINARY NOT NULL");
-    f.checkScalar("RIGHTSHIFT(CAST(X'F0' AS VARBINARY), 4)", "0f",
-        "VARBINARY NOT NULL");
-    f.checkScalar("RIGHTSHIFT(CAST(X'FFFF' AS VARBINARY), 1)", "ff7f",
-        "VARBINARY NOT NULL");
-    f.checkScalar("RIGHTSHIFT(CAST(X'123456' AS VARBINARY), 4)", "416305",
-        "VARBINARY NOT NULL");
-    // 8 % (8 * 1) = 0 leaves the 1-byte value unchanged, while 8 % (8 * 2) = 8
-    // shifts the 2-byte value by a whole byte: the width follows the value.
-    f.checkScalar("RIGHTSHIFT(CAST(X'FF' AS VARBINARY), 8)", "ff",
-        "VARBINARY NOT NULL");
-    f.checkScalar("RIGHTSHIFT(CAST(X'FFFF' AS VARBINARY), 8)", "ff00",
-        "VARBINARY NOT NULL");
-    f.checkScalar("RIGHTSHIFT(CAST(X'F0' AS VARBINARY), -4)", "0f",
-        "VARBINARY NOT NULL");
+    // === Binary operands are not supported ===
+    // Unlike LEFTSHIFT, binary right shift is intentionally rejected until the
+    // endianness of bitwise shifts on binary is settled (see [CALCITE-7651]).
+    // A binary literal such as X'FF' already has type BINARY(1).
+    f.checkFails("^RIGHTSHIFT(X'FF', 1)^",
+        "Cannot apply 'RIGHTSHIFT' to arguments of type 'RIGHTSHIFT\\(<BINARY\\(1\\)>, <INTEGER>\\)'\\. Supported form\\(s\\): 'RIGHTSHIFT\\(<INTEGER>, <INTEGER>\\)'\\n'RIGHTSHIFT\\(<UNSIGNED_NUMERIC>, <INTEGER>\\)'",
+        false);
+    f.checkFails("^RIGHTSHIFT(CAST(X'FF' AS VARBINARY), 1)^",
+        "Cannot apply 'RIGHTSHIFT' to arguments of type 'RIGHTSHIFT\\(<VARBINARY>, <INTEGER>\\)'\\. Supported form\\(s\\): 'RIGHTSHIFT\\(<INTEGER>, <INTEGER>\\)'\\n'RIGHTSHIFT\\(<UNSIGNED_NUMERIC>, <INTEGER>\\)'",
+        false);
+
     // === Invalid types ===
     f.checkFails("^RIGHTSHIFT(1.2, 2)^",
-        "Cannot apply 'RIGHTSHIFT' to arguments of type 'RIGHTSHIFT\\(<DECIMAL\\(2, 1\\)>, <INTEGER>\\)'\\. Supported form\\(s\\): 'RIGHTSHIFT\\(<INTEGER>, <INTEGER>\\)'\\n'RIGHTSHIFT\\(<BINARY>, <INTEGER>\\)'\\n'RIGHTSHIFT\\(<UNSIGNED_NUMERIC>, <INTEGER>\\)'",
+        "Cannot apply 'RIGHTSHIFT' to arguments of type 'RIGHTSHIFT\\(<DECIMAL\\(2, 1\\)>, <INTEGER>\\)'\\. Supported form\\(s\\): 'RIGHTSHIFT\\(<INTEGER>, <INTEGER>\\)'\\n'RIGHTSHIFT\\(<UNSIGNED_NUMERIC>, <INTEGER>\\)'",
         false);
     // A BIGINT shift amount is accepted, but an unsigned shift amount is not:
     // the second argument must be a signed integer type.
     f.checkScalar("RIGHTSHIFT(8, CAST(2 AS BIGINT))", "2", "INTEGER NOT NULL");
     f.checkFails("^RIGHTSHIFT(8, CAST(2 AS INTEGER UNSIGNED))^",
-        "Cannot apply 'RIGHTSHIFT' to arguments of type 'RIGHTSHIFT\\(<INTEGER>, <INTEGER UNSIGNED>\\)'\\. Supported form\\(s\\): 'RIGHTSHIFT\\(<INTEGER>, <INTEGER>\\)'\\n'RIGHTSHIFT\\(<BINARY>, <INTEGER>\\)'\\n'RIGHTSHIFT\\(<UNSIGNED_NUMERIC>, <INTEGER>\\)'",
+        "Cannot apply 'RIGHTSHIFT' to arguments of type 'RIGHTSHIFT\\(<INTEGER>, <INTEGER UNSIGNED>\\)'\\. Supported form\\(s\\): 'RIGHTSHIFT\\(<INTEGER>, <INTEGER>\\)'\\n'RIGHTSHIFT\\(<UNSIGNED_NUMERIC>, <INTEGER>\\)'",
         false);