feat: Add decimal support in histogram aggregate (facebookincubator#12811)

Summary:
Pull Request resolved: facebookincubator#12811

Add long decimal support in histogram aggregate. Short decimal is handled through BIGINT

Reviewed By: kgpai

Differential Revision: D71860678

fbshipit-source-id: 1c8b32fba1b282196573500f42f32e2abf9a2328

Author: singcha

velox/functions/prestosql/aggregates/HistogramAggregate.cpp

@@ -624,6 +624,11 @@ void registerHistogramAggregate(
           case TypeKind::ROW:
             return std::make_unique<HistogramAggregate<ComplexType>>(
                 resultType);
+          case TypeKind::HUGEINT:
+            if (inputType->isLongDecimal()) {
+              return std::make_unique<HistogramAggregate<int128_t>>(resultType);
+            }
+            [[fallthrough]];
           case TypeKind::UNKNOWN:
             return std::make_unique<HistogramAggregate<int8_t>>(resultType);
           default:

velox/functions/prestosql/aggregates/tests/HistogramTest.cpp

@@ -28,6 +28,11 @@ namespace facebook::velox::aggregate::test {
 
 namespace {
 
+constexpr int64_t kLongMax = std::numeric_limits<int64_t>::max();
+constexpr int64_t kLongMin = std::numeric_limits<int64_t>::min();
+constexpr int128_t kHugeMax = std::numeric_limits<int128_t>::max();
+constexpr int128_t kHugeMin = std::numeric_limits<int128_t>::min();
+
 class HistogramTest : public AggregationTestBase {
  protected:
   void SetUp() override {
@@ -234,6 +239,136 @@ TEST_F(HistogramTest, groupByTimestampWithTimezones) {
   testHistogram("histogram(c1)", {"c0"}, keys, vector, expected);
 }
 
+TEST_F(HistogramTest, groupByLongDecimal) {
+  auto type = DECIMAL(30, 2);
+
+  auto vector = makeFlatVector<int128_t>({1000, 1001, 1002, 1003, 1000}, type);
+  auto keys = makeFlatVector<int16_t>(5, [](auto row) { return row % 2; });
+  auto expected = makeRowVector(
+      {makeFlatVector<int16_t>({0, 1}),
+       makeMapVector<int128_t, int64_t>(
+           {{{{1000}, 2}, {{1002}, 1}}, {{{1001}, 1}, {{1003}, 1}}},
+           MAP(type, BIGINT()))});
+
+  testHistogram("histogram(c1)", {"c0"}, keys, vector, expected);
+
+  // with commonly used precision & scale
+  auto type1 = DECIMAL(38, 0);
+  auto vector1 = makeFlatVector<int128_t>({1000, 1001, 1002, 1003, 1000}, type);
+  auto keys1 = makeFlatVector<int16_t>(5, [](auto row) { return row % 2; });
+  auto expected1 = makeRowVector(
+      {makeFlatVector<int16_t>({0, 1}),
+       makeMapVector<int128_t, int64_t>(
+           {{{{1000}, 2}, {{1002}, 1}}, {{{1001}, 1}, {{1003}, 1}}},
+           MAP(type, BIGINT()))});
+
+  testHistogram("histogram(c1)", {"c0"}, keys1, vector1, expected1);
+}
+
+TEST_F(HistogramTest, groupByShortDecimal) {
+  auto type = DECIMAL(5, 2);
+
+  auto vector = makeFlatVector<int64_t>({1000, 1001, 1002, 1003, 1000}, type);
+  auto keys = makeFlatVector<int16_t>(5, [](auto row) { return row % 2; });
+  auto expected = makeRowVector(
+      {makeFlatVector<int16_t>({0, 1}),
+       makeMapVector<int64_t, int64_t>(
+           {{{{1000}, 2}, {{1002}, 1}}, {{{1001}, 1}, {{1003}, 1}}},
+           MAP(type, BIGINT()))});
+
+  testHistogram("histogram(c1)", {"c0"}, keys, vector, expected);
+}
+
+TEST_F(HistogramTest, globalLongDecimal) {
+  auto type = DECIMAL(30, 2);
+
+  auto vector = makeFlatVector<int128_t>(
+      {10023, kHugeMax, 20035, 10023, kHugeMin, 40033, kHugeMin}, type);
+  auto expected = makeRowVector({makeMapVector<int128_t, int64_t>(
+      {{{{kHugeMin}, 2},
+        {{10023}, 2},
+        {{20035}, 1},
+        {{40033}, 1},
+        {{kHugeMax}, 1}}},
+      MAP(type, BIGINT()))});
+
+  testHistogram("histogram(c1)", {}, vector, vector, expected);
+
+  // with nullable vectors
+  auto vectorWithNulls = makeNullableFlatVector<int128_t>(
+      {10023,
+       kHugeMax,
+       std::nullopt,
+       std::nullopt,
+       20035,
+       10023,
+       kHugeMin,
+       40033,
+       std::nullopt,
+       kHugeMin},
+      type);
+  auto expectedResultWithNullInputs =
+      makeRowVector({makeMapVector<int128_t, int64_t>(
+          {{{{kHugeMin}, 2},
+            {{10023}, 2},
+            {{20035}, 1},
+            {{40033}, 1},
+            {{kHugeMax}, 1}}},
+          MAP(type, BIGINT()))});
+
+  testHistogram(
+      "histogram(c1)",
+      {},
+      vectorWithNulls,
+      vectorWithNulls,
+      expectedResultWithNullInputs);
+}
+
+TEST_F(HistogramTest, gllobalShortDecimal) {
+  auto type = DECIMAL(5, 2);
+
+  auto vector = makeFlatVector<int64_t>(
+      {10023, kLongMax, 20035, 10023, kLongMin, 40033, kLongMin}, type);
+  auto expected = makeRowVector({makeMapVector<int64_t, int64_t>(
+      {{{{kLongMin}, 2},
+        {{10023}, 2},
+        {{20035}, 1},
+        {{40033}, 1},
+        {{kLongMax}, 1}}},
+      MAP(type, BIGINT()))});
+
+  testHistogram("histogram(c1)", {}, vector, vector, expected);
+
+  // with nullable vectors
+  auto vectorWithNulls = makeNullableFlatVector<int64_t>(
+      {10023,
+       kLongMax,
+       std::nullopt,
+       std::nullopt,
+       20035,
+       10023,
+       kLongMin,
+       40033,
+       std::nullopt,
+       kLongMin},
+      type);
+  auto expectedResultWithNullInputs =
+      makeRowVector({makeMapVector<int64_t, int64_t>(
+          {{{{kLongMin}, 2},
+            {{10023}, 2},
+            {{20035}, 1},
+            {{40033}, 1},
+            {{kLongMax}, 1}}},
+          MAP(type, BIGINT()))});
+
+  testHistogram(
+      "histogram(c1)",
+      {},
+      vectorWithNulls,
+      vectorWithNulls,
+      expectedResultWithNullInputs);
+}
+
 TEST_F(HistogramTest, globalInteger) {
   vector_size_t num = 29;
   auto vector = makeFlatVector<int32_t>(