cyb70289 commented on a change in pull request #10364:
URL: https://github.com/apache/arrow/pull/10364#discussion_r645953547
##########
File path: cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
##########
@@ -428,12 +524,69 @@ ArrayKernelExec ArithmeticExecFromOp(detail::GetTypeId
get_id) {
}
}
+// calculate output precision/scale and args rescaling per operation type
+Result<std::shared_ptr<DataType>> GetDecimalBinaryOutput(
+ const std::string& op, const std::vector<ValueDescr>& values,
+ std::vector<std::shared_ptr<DataType>>* replaced = nullptr) {
+ const auto& left_type = checked_pointer_cast<DecimalType>(values[0].type);
+ const auto& right_type = checked_pointer_cast<DecimalType>(values[1].type);
+
+ const int32_t p1 = left_type->precision(), s1 = left_type->scale();
+ const int32_t p2 = right_type->precision(), s2 = right_type->scale();
+ if (s1 < 0 || s2 < 0) {
+ return Status::NotImplemented("Decimals with negative scales not
supported");
+ }
+
+ int32_t out_prec, out_scale;
+ int32_t left_scaleup = 0, right_scaleup = 0;
+
+ // decimal upscaling behaviour references amazon redshift
+ //
https://docs.aws.amazon.com/redshift/latest/dg/r_numeric_computations201.html
+ if (op.find("add") == 0 || op.find("subtract") == 0) {
+ out_scale = std::max(s1, s2);
+ out_prec = std::max(p1 - s1, p2 - s2) + 1 + out_scale;
+ left_scaleup = out_scale - s1;
+ right_scaleup = out_scale - s2;
+ } else if (op.find("multiply") == 0) {
+ out_scale = s1 + s2;
+ out_prec = p1 + p2 + 1;
+ } else if (op.find("divide") == 0) {
+ out_scale = std::max(4, s1 + p2 - s2 + 1);
+ out_prec = p1 - s1 + s2 + out_scale; // >= p1 + p2 + 1
+ left_scaleup = out_prec - p1;
+ } else {
+ return Status::Invalid("Invalid decimal operation: ", op);
+ }
+
+ const auto id = left_type->id();
+ auto make = [id](int32_t precision, int32_t scale) {
+ if (id == Type::DECIMAL128) {
+ return Decimal128Type::Make(precision, scale);
+ } else {
+ return Decimal256Type::Make(precision, scale);
+ }
+ };
+
+ if (replaced) {
+ replaced->resize(2);
+ ARROW_ASSIGN_OR_RAISE((*replaced)[0], make(p1 + left_scaleup, s1 +
left_scaleup));
+ ARROW_ASSIGN_OR_RAISE((*replaced)[1], make(p2 + right_scaleup, s2 +
right_scaleup));
+ }
+
+ return make(out_prec, out_scale);
+}
+
struct ArithmeticFunction : ScalarFunction {
using ScalarFunction::ScalarFunction;
Result<const Kernel*> DispatchBest(std::vector<ValueDescr>* values) const
override {
RETURN_NOT_OK(CheckArity(*values));
+ const auto type_id = (*values)[0].type->id();
Review comment:
Looks it's straightforward to implement. Will add `decimal + float`
operation in this PR.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
