Function TestScaleBy

be/src/exprs/expr-test.cc:3124–3164

};

void TestScaleBy() {
  // IMPALA-6429: There is a shortcut in the decimal division. If we estimate that the
  // dividend requires more than 255 bits after scaling up, we overflow right away. This
  // test proves that it is correct to do this and no other checks are needed.
  for (int scale_by = 0; scale_by < 38 * 2 + 1; ++scale_by) {
    for (int num_bits = 1; num_bits < 128; ++num_bits) {
      // We set the dividend to be the smallest number that requires a certain number of
      // bits.
      int128_t dividend = 1;
      dividend <<= num_bits - 1;
      int256_t scaled_up_dividend = DecimalUtil::MultiplyByScale<int256_t>(
          ConvertToInt256(dividend), scale_by, true);
      int256_t scale_multiplier = DecimalUtil::GetScaleMultiplier<int256_t>(scale_by);
      if (detail::MaxBitsRequiredAfterScaling(dividend, scale_by) <= 255) {
        // If we estimate that the scaled up dividend requires 255 bits or less, verify
        // that we do not overflow when scaling up.
        EXPECT_TRUE(scaled_up_dividend / scale_multiplier == ConvertToInt256(dividend));
        EXPECT_TRUE(
            (-scaled_up_dividend) / scale_multiplier == ConvertToInt256(-dividend));
      } else {
        // If we estimate that scaled up dividend requres more than 255 bits, we want to
        // verify that it is safe to set the result of the division to overflow.
        if (scaled_up_dividend / scale_multiplier == ConvertToInt256(dividend)) {
          // In this case, scaling up did not overflow. Verify that the scaled up
          // dividend is too large. Even if we divide it by the largest possible divisor
          // the result is larger than MAX_UNSCALED_DECIMAL16, which means the division
          // overflows in all cases.
          EXPECT_TRUE((-scaled_up_dividend) / scale_multiplier ==
              ConvertToInt256(-dividend));
          int256_t max_divisor = ConvertToInt256(MAX_UNSCALED_DECIMAL16);
          EXPECT_TRUE(scaled_up_dividend / max_divisor > max_divisor);
          EXPECT_TRUE((-scaled_up_dividend) / max_divisor < -max_divisor);
        } else {
          // There was an overflow when scaling up.
          EXPECT_TRUE((-scaled_up_dividend) / scale_multiplier !=
              ConvertToInt256(-dividend));
        }
      }
    }
  }
}

TEST_P(ExprTest, DecimalArithmeticExprs) {
  // Test with both decimal_v2={false, true}