diff --git a/cpp/src/arrow/acero/tpch_benchmark.cc b/cpp/src/arrow/acero/tpch_benchmark.cc
index aa621758b351e..ac3b69c9b706f 100644
--- a/cpp/src/arrow/acero/tpch_benchmark.cc
+++ b/cpp/src/arrow/acero/tpch_benchmark.cc
@@ -58,7 +58,7 @@ std::shared_ptr<ExecPlan> Plan_Q1(AsyncGenerator<std::optional<ExecBatch>>* sink
   Expression base_price = field_ref("L_EXTENDEDPRICE");
 
   std::shared_ptr<Decimal128Scalar> decimal_1 =
-      std::make_shared<Decimal128Scalar>(Decimal128{0, 100}, decimal(12, 2));
+      std::make_shared<Decimal128Scalar>(Decimal128{0, 100}, decimal128(12, 2));
   Expression discount_multiplier =
       call("subtract", {literal(decimal_1), field_ref("L_DISCOUNT")});
   Expression tax_multiplier = call("add", {literal(decimal_1), field_ref("L_TAX")});
@@ -68,7 +68,7 @@ std::shared_ptr<ExecPlan> Plan_Q1(AsyncGenerator<std::optional<ExecBatch>>* sink
       call("multiply",
            {call("cast",
                  {call("multiply", {field_ref("L_EXTENDEDPRICE"), discount_multiplier})},
-                 compute::CastOptions::Unsafe(decimal(12, 2))),
+                 compute::CastOptions::Unsafe(decimal128(12, 2))),
             tax_multiplier});
   Expression discount = field_ref("L_DISCOUNT");
 
diff --git a/cpp/src/arrow/acero/tpch_node.cc b/cpp/src/arrow/acero/tpch_node.cc
index 137b62ad38a95..abc742f9fa10b 100644
--- a/cpp/src/arrow/acero/tpch_node.cc
+++ b/cpp/src/arrow/acero/tpch_node.cc
@@ -838,12 +838,12 @@ class PartAndPartSupplierGenerator {
 
   const std::vector<std::shared_ptr<DataType>> kPartTypes = {
       int32(), utf8(),  fixed_size_binary(25), fixed_size_binary(10),
-      utf8(),  int32(), fixed_size_binary(10), decimal(12, 2),
+      utf8(),  int32(), fixed_size_binary(10), decimal128(12, 2),
       utf8(),
   };
 
   const std::vector<std::shared_ptr<DataType>> kPartsuppTypes = {
-      int32(), int32(), int32(), decimal(12, 2), utf8(),
+      int32(), int32(), int32(), decimal128(12, 2), utf8(),
   };
 
   Status AllocatePartBatch(size_t thread_index, int column) {
@@ -1527,7 +1527,7 @@ class OrdersAndLineItemGenerator {
   const std::vector<std::shared_ptr<DataType>> kOrdersTypes = {int32(),
                                                                int32(),
                                                                fixed_size_binary(1),
-                                                               decimal(12, 2),
+                                                               decimal128(12, 2),
                                                                date32(),
                                                                fixed_size_binary(15),
                                                                fixed_size_binary(15),
@@ -1539,10 +1539,10 @@ class OrdersAndLineItemGenerator {
       int32(),
       int32(),
       int32(),
-      decimal(12, 2),
-      decimal(12, 2),
-      decimal(12, 2),
-      decimal(12, 2),
+      decimal128(12, 2),
+      decimal128(12, 2),
+      decimal128(12, 2),
+      decimal128(12, 2),
       fixed_size_binary(1),
       fixed_size_binary(1),
       date32(),
@@ -2489,7 +2489,7 @@ class SupplierGenerator : public TpchTableGenerator {
 
   std::vector<std::shared_ptr<DataType>> kTypes = {
       int32(), fixed_size_binary(25), utf8(),
-      int32(), fixed_size_binary(15), decimal(12, 2),
+      int32(), fixed_size_binary(15), decimal128(12, 2),
       utf8(),
   };
 
@@ -2872,7 +2872,7 @@ class CustomerGenerator : public TpchTableGenerator {
       utf8(),
       int32(),
       fixed_size_binary(15),
-      decimal(12, 2),
+      decimal128(12, 2),
       fixed_size_binary(10),
       utf8(),
   };
diff --git a/cpp/src/arrow/array/array_base.cc b/cpp/src/arrow/array/array_base.cc
index 6927f51283eb7..ce2e66655af3d 100644
--- a/cpp/src/arrow/array/array_base.cc
+++ b/cpp/src/arrow/array/array_base.cc
@@ -74,6 +74,10 @@ struct ScalarFromArraySlotImpl {
     return Finish(a.Value(index_));
   }
 
+  Status Visit(const Decimal32Array& a) { return Finish(Decimal32(a.GetValue(index_))); }
+
+  Status Visit(const Decimal64Array& a) { return Finish(Decimal64(a.GetValue(index_))); }
+
   Status Visit(const Decimal128Array& a) {
     return Finish(Decimal128(a.GetValue(index_)));
   }
diff --git a/cpp/src/arrow/array/array_decimal.cc b/cpp/src/arrow/array/array_decimal.cc
index d65f6ee53564f..a2c9cae3451a1 100644
--- a/cpp/src/arrow/array/array_decimal.cc
+++ b/cpp/src/arrow/array/array_decimal.cc
@@ -32,6 +32,34 @@ namespace arrow {
 
 using internal::checked_cast;
 
+// ----------------------------------------------------------------------
+// Decimal32
+
+Decimal32Array::Decimal32Array(const std::shared_ptr<ArrayData>& data)
+    : FixedSizeBinaryArray(data) {
+  ARROW_CHECK_EQ(data->type->id(), Type::DECIMAL32);
+}
+
+std::string Decimal32Array::FormatValue(int64_t i) const {
+  const auto& type_ = checked_cast<const Decimal32Type&>(*type());
+  const Decimal32 value(GetValue(i));
+  return value.ToString(type_.scale());
+}
+
+// ----------------------------------------------------------------------
+// Decimal64
+
+Decimal64Array::Decimal64Array(const std::shared_ptr<ArrayData>& data)
+    : FixedSizeBinaryArray(data) {
+  ARROW_CHECK_EQ(data->type->id(), Type::DECIMAL64);
+}
+
+std::string Decimal64Array::FormatValue(int64_t i) const {
+  const auto& type_ = checked_cast<const Decimal64Type&>(*type());
+  const Decimal64 value(GetValue(i));
+  return value.ToString(type_.scale());
+}
+
 // ----------------------------------------------------------------------
 // Decimal128
 
diff --git a/cpp/src/arrow/array/array_decimal.h b/cpp/src/arrow/array/array_decimal.h
index f14812549089a..2f10bb8429996 100644
--- a/cpp/src/arrow/array/array_decimal.h
+++ b/cpp/src/arrow/array/array_decimal.h
@@ -32,6 +32,38 @@ namespace arrow {
 ///
 /// @{
 
+// ----------------------------------------------------------------------
+// Decimal32Array
+
+/// Concrete Array class for 32-bit decimal data
+class ARROW_EXPORT Decimal32Array : public FixedSizeBinaryArray {
+ public:
+  using TypeClass = Decimal32Type;
+
+  using FixedSizeBinaryArray::FixedSizeBinaryArray;
+
+  /// \brief Construct Decimal32Array from ArrayData instance
+  explicit Decimal32Array(const std::shared_ptr<ArrayData>& data);
+
+  std::string FormatValue(int64_t i) const;
+};
+
+// ----------------------------------------------------------------------
+// Decimal64Array
+
+/// Concrete Array class for 64-bit decimal data
+class ARROW_EXPORT Decimal64Array : public FixedSizeBinaryArray {
+ public:
+  using TypeClass = Decimal64Type;
+
+  using FixedSizeBinaryArray::FixedSizeBinaryArray;
+
+  /// \brief Construct Decimal64Array from ArrayData instance
+  explicit Decimal64Array(const std::shared_ptr<ArrayData>& data);
+
+  std::string FormatValue(int64_t i) const;
+};
+
 // ----------------------------------------------------------------------
 // Decimal128Array
 
diff --git a/cpp/src/arrow/array/array_test.cc b/cpp/src/arrow/array/array_test.cc
index 73e0c692432b6..d69e00460dcfc 100644
--- a/cpp/src/arrow/array/array_test.cc
+++ b/cpp/src/arrow/array/array_test.cc
@@ -442,7 +442,7 @@ static std::vector<std::shared_ptr<DataType>> TestArrayUtilitiesAgainstTheseType
       large_binary(),
       binary_view(),
       fixed_size_binary(3),
-      decimal(16, 4),
+      decimal128(16, 4),
       utf8(),
       large_utf8(),
       utf8_view(),
@@ -667,8 +667,10 @@ static ScalarVector GetScalars() {
       std::make_shared<BinaryViewScalar>(hello),
       std::make_shared<FixedSizeBinaryScalar>(
           hello, fixed_size_binary(static_cast<int32_t>(hello->size()))),
-      std::make_shared<Decimal128Scalar>(Decimal128(10), decimal(16, 4)),
-      std::make_shared<Decimal256Scalar>(Decimal256(10), decimal(76, 38)),
+      std::make_shared<Decimal32Scalar>(Decimal32(10), smallest_decimal(7, 4)),
+      std::make_shared<Decimal64Scalar>(Decimal64(10), smallest_decimal(12, 4)),
+      std::make_shared<Decimal128Scalar>(Decimal128(10), smallest_decimal(20, 4)),
+      std::make_shared<Decimal256Scalar>(Decimal256(10), smallest_decimal(76, 38)),
       std::make_shared<StringScalar>(hello),
       std::make_shared<LargeStringScalar>(hello),
       std::make_shared<StringViewScalar>(hello),
@@ -3092,6 +3094,98 @@ class DecimalTest : public ::testing::TestWithParam<int> {
   }
 };
 
+using Decimal32Test = DecimalTest<Decimal32Type>;
+
+TEST_P(Decimal32Test, NoNulls) {
+  int32_t precision = GetParam();
+  std::vector<Decimal32> draw = {Decimal32(1), Decimal32(-2), Decimal32(2389),
+                                 Decimal32(4), Decimal32(-12348)};
+  std::vector<uint8_t> valid_bytes = {true, true, true, true, true};
+  this->TestCreate(precision, draw, valid_bytes, 0);
+  this->TestCreate(precision, draw, valid_bytes, 2);
+}
+
+TEST_P(Decimal32Test, WithNulls) {
+  int32_t precision = GetParam();
+  std::vector<Decimal32> draw = {Decimal32(1),  Decimal32(2), Decimal32(-1), Decimal32(4),
+                                 Decimal32(-1), Decimal32(1), Decimal32(2)};
+  Decimal32 big;
+  ASSERT_OK_AND_ASSIGN(big, Decimal32::FromString("23034.234"));
+  draw.push_back(big);
+
+  Decimal32 big_negative;
+  ASSERT_OK_AND_ASSIGN(big_negative, Decimal32::FromString("-23049.235"));
+  draw.push_back(big_negative);
+
+  std::vector<uint8_t> valid_bytes = {true, true, false, true, false,
+                                      true, true, true,  true};
+  this->TestCreate(precision, draw, valid_bytes, 0);
+  this->TestCreate(precision, draw, valid_bytes, 2);
+}
+
+TEST_P(Decimal32Test, ValidateFull) {
+  int32_t precision = GetParam();
+  std::vector<Decimal32> draw;
+  Decimal32 val = Decimal32::GetMaxValue(precision) + 1;
+
+  draw = {Decimal32(), val};
+  auto arr = this->TestCreate(precision, draw, {true, false}, 0);
+  ASSERT_OK(arr->ValidateFull());
+
+  draw = {val, Decimal32()};
+  arr = this->TestCreate(precision, draw, {true, false}, 0);
+  EXPECT_RAISES_WITH_MESSAGE_THAT(
+      Invalid, ::testing::HasSubstr("does not fit in precision of"), arr->ValidateFull());
+}
+
+INSTANTIATE_TEST_SUITE_P(Decimal32Test, Decimal32Test, ::testing::Range(1, 9));
+
+using Decimal64Test = DecimalTest<Decimal64Type>;
+
+TEST_P(Decimal64Test, NoNulls) {
+  int32_t precision = GetParam();
+  std::vector<Decimal64> draw = {Decimal64(1), Decimal64(-2), Decimal64(2389),
+                                 Decimal64(4), Decimal64(-12348)};
+  std::vector<uint8_t> valid_bytes = {true, true, true, true, true};
+  this->TestCreate(precision, draw, valid_bytes, 0);
+  this->TestCreate(precision, draw, valid_bytes, 2);
+}
+
+TEST_P(Decimal64Test, WithNulls) {
+  int32_t precision = GetParam();
+  std::vector<Decimal64> draw = {Decimal64(1),  Decimal64(2), Decimal64(-1), Decimal64(4),
+                                 Decimal64(-1), Decimal64(1), Decimal64(2)};
+  Decimal64 big;
+  ASSERT_OK_AND_ASSIGN(big, Decimal64::FromString("23034.234234"));
+  draw.push_back(big);
+
+  Decimal64 big_negative;
+  ASSERT_OK_AND_ASSIGN(big_negative, Decimal64::FromString("-23049.235234"));
+  draw.push_back(big_negative);
+
+  std::vector<uint8_t> valid_bytes = {true, true, false, true, false,
+                                      true, true, true,  true};
+  this->TestCreate(precision, draw, valid_bytes, 0);
+  this->TestCreate(precision, draw, valid_bytes, 2);
+}
+
+TEST_P(Decimal64Test, ValidateFull) {
+  int32_t precision = GetParam();
+  std::vector<Decimal64> draw;
+  Decimal64 val = Decimal64::GetMaxValue(precision) + 1;
+
+  draw = {Decimal64(), val};
+  auto arr = this->TestCreate(precision, draw, {true, false}, 0);
+  ASSERT_OK(arr->ValidateFull());
+
+  draw = {val, Decimal64()};
+  arr = this->TestCreate(precision, draw, {true, false}, 0);
+  EXPECT_RAISES_WITH_MESSAGE_THAT(
+      Invalid, ::testing::HasSubstr("does not fit in precision of"), arr->ValidateFull());
+}
+
+INSTANTIATE_TEST_SUITE_P(Decimal64Test, Decimal64Test, ::testing::Range(1, 9));
+
 using Decimal128Test = DecimalTest<Decimal128Type>;
 
 TEST_P(Decimal128Test, NoNulls) {
@@ -3315,6 +3409,28 @@ TEST(TestSwapEndianArrayData, PrimitiveType) {
   expected_data = ArrayData::Make(uint64(), 1, {null_buffer, data_int64_buffer}, 0);
   AssertArrayDataEqualsWithSwapEndian(data, expected_data);
 
+  auto data_4byte_buffer = Buffer::FromString(
+      "\x01"
+      "12\x01");
+  data = ArrayData::Make(decimal32(9, 8), 1, {null_buffer, data_4byte_buffer});
+  auto data_decimal32_buffer = Buffer::FromString(
+      "\x01"
+      "21\x01");
+  expected_data =
+      ArrayData::Make(decimal32(9, 8), 1, {null_buffer, data_decimal32_buffer}, 0);
+  AssertArrayDataEqualsWithSwapEndian(data, expected_data);
+
+  auto data_8byte_buffer = Buffer::FromString(
+      "\x01"
+      "123456\x01");
+  data = ArrayData::Make(decimal64(18, 8), 1, {null_buffer, data_8byte_buffer});
+  auto data_decimal64_buffer = Buffer::FromString(
+      "\x01"
+      "654321\x01");
+  expected_data =
+      ArrayData::Make(decimal64(18, 8), 1, {null_buffer, data_decimal64_buffer}, 0);
+  AssertArrayDataEqualsWithSwapEndian(data, expected_data);
+
   auto data_16byte_buffer = Buffer::FromString(
       "\x01"
       "123456789abcde\x01");
@@ -3647,6 +3763,8 @@ DataTypeVector SwappableTypes() {
                         uint16(),
                         uint32(),
                         uint64(),
+                        decimal32(8, 1),
+                        decimal64(16, 2),
                         decimal128(19, 4),
                         decimal256(37, 8),
                         timestamp(TimeUnit::MICRO, ""),
diff --git a/cpp/src/arrow/array/array_view_test.cc b/cpp/src/arrow/array/array_view_test.cc
index 97110ea97f3fc..a8d6d8ffa3e79 100644
--- a/cpp/src/arrow/array/array_view_test.cc
+++ b/cpp/src/arrow/array/array_view_test.cc
@@ -385,8 +385,32 @@ TEST(TestArrayView, SparseUnionAsStruct) {
   CheckView(expected, arr);
 }
 
-TEST(TestArrayView, DecimalRoundTrip) {
-  auto ty1 = decimal(10, 4);
+TEST(TestArrayView, Decimal32RoundTrip) {
+  auto ty1 = decimal32(9, 4);
+  auto arr = ArrayFromJSON(ty1, R"(["123.4567", "-78.9000", null])");
+
+  auto ty2 = fixed_size_binary(4);
+  ASSERT_OK_AND_ASSIGN(auto v, arr->View(ty2));
+  ASSERT_OK(v->ValidateFull());
+  ASSERT_OK_AND_ASSIGN(auto w, v->View(ty1));
+  ASSERT_OK(w->ValidateFull());
+  AssertArraysEqual(*arr, *w);
+}
+
+TEST(TestArrayView, Decimal64RoundTrip) {
+  auto ty1 = decimal64(10, 4);
+  auto arr = ArrayFromJSON(ty1, R"(["123.4567", "-78.9000", null])");
+
+  auto ty2 = fixed_size_binary(8);
+  ASSERT_OK_AND_ASSIGN(auto v, arr->View(ty2));
+  ASSERT_OK(v->ValidateFull());
+  ASSERT_OK_AND_ASSIGN(auto w, v->View(ty1));
+  ASSERT_OK(w->ValidateFull());
+  AssertArraysEqual(*arr, *w);
+}
+
+TEST(TestArrayView, Decimal128RoundTrip) {
+  auto ty1 = decimal128(20, 4);
   auto arr = ArrayFromJSON(ty1, R"(["123.4567", "-78.9000", null])");
 
   auto ty2 = fixed_size_binary(16);
@@ -397,6 +421,18 @@ TEST(TestArrayView, DecimalRoundTrip) {
   AssertArraysEqual(*arr, *w);
 }
 
+TEST(TestArrayView, Decimal256RoundTrip) {
+  auto ty1 = decimal256(10, 4);
+  auto arr = ArrayFromJSON(ty1, R"(["123.4567", "-78.9000", null])");
+
+  auto ty2 = fixed_size_binary(32);
+  ASSERT_OK_AND_ASSIGN(auto v, arr->View(ty2));
+  ASSERT_OK(v->ValidateFull());
+  ASSERT_OK_AND_ASSIGN(auto w, v->View(ty1));
+  ASSERT_OK(w->ValidateFull());
+  AssertArraysEqual(*arr, *w);
+}
+
 TEST(TestArrayView, Dictionaries) {
   // ARROW-6049
   auto ty1 = dictionary(int8(), float32());
diff --git a/cpp/src/arrow/array/builder_base.cc b/cpp/src/arrow/array/builder_base.cc
index 40e705aa3e440..2e6e1bfd13032 100644
--- a/cpp/src/arrow/array/builder_base.cc
+++ b/cpp/src/arrow/array/builder_base.cc
@@ -119,6 +119,8 @@ struct AppendScalarImpl {
   }
 
   Status Visit(const FixedSizeBinaryType& t) { return HandleFixedWidth(t); }
+  Status Visit(const Decimal32Type& t) { return HandleFixedWidth(t); }
+  Status Visit(const Decimal64Type& t) { return HandleFixedWidth(t); }
   Status Visit(const Decimal128Type& t) { return HandleFixedWidth(t); }
   Status Visit(const Decimal256Type& t) { return HandleFixedWidth(t); }
 
diff --git a/cpp/src/arrow/array/builder_decimal.cc b/cpp/src/arrow/array/builder_decimal.cc
index 3b1262819df7f..868183768c1d1 100644
--- a/cpp/src/arrow/array/builder_decimal.cc
+++ b/cpp/src/arrow/array/builder_decimal.cc
@@ -32,6 +32,76 @@ namespace arrow {
 class Buffer;
 class MemoryPool;
 
+// ----------------------------------------------------------------------
+// Decimal32Builder
+
+Decimal32Builder::Decimal32Builder(const std::shared_ptr<DataType>& type,
+                                   MemoryPool* pool, int64_t alignment)
+    : FixedSizeBinaryBuilder(type, pool, alignment),
+      decimal_type_(internal::checked_pointer_cast<Decimal32Type>(type)) {}
+
+Status Decimal32Builder::Append(Decimal32 value) {
+  RETURN_NOT_OK(FixedSizeBinaryBuilder::Reserve(1));
+  UnsafeAppend(value);
+  return Status::OK();
+}
+
+void Decimal32Builder::UnsafeAppend(Decimal32 value) {
+  value.ToBytes(GetMutableValue(length()));
+  byte_builder_.UnsafeAdvance(4);
+  UnsafeAppendToBitmap(true);
+}
+
+void Decimal32Builder::UnsafeAppend(std::string_view value) {
+  FixedSizeBinaryBuilder::UnsafeAppend(value);
+}
+
+Status Decimal32Builder::FinishInternal(std::shared_ptr<ArrayData>* out) {
+  std::shared_ptr<Buffer> data;
+  RETURN_NOT_OK(byte_builder_.Finish(&data));
+  std::shared_ptr<Buffer> null_bitmap;
+  RETURN_NOT_OK(null_bitmap_builder_.Finish(&null_bitmap));
+
+  *out = ArrayData::Make(type(), length_, {null_bitmap, data}, null_count_);
+  capacity_ = length_ = null_count_ = 0;
+  return Status::OK();
+}
+
+// ----------------------------------------------------------------------
+// Decimal64Builder
+
+Decimal64Builder::Decimal64Builder(const std::shared_ptr<DataType>& type,
+                                   MemoryPool* pool, int64_t alignment)
+    : FixedSizeBinaryBuilder(type, pool, alignment),
+      decimal_type_(internal::checked_pointer_cast<Decimal64Type>(type)) {}
+
+Status Decimal64Builder::Append(Decimal64 value) {
+  RETURN_NOT_OK(FixedSizeBinaryBuilder::Reserve(1));
+  UnsafeAppend(value);
+  return Status::OK();
+}
+
+void Decimal64Builder::UnsafeAppend(Decimal64 value) {
+  value.ToBytes(GetMutableValue(length()));
+  byte_builder_.UnsafeAdvance(8);
+  UnsafeAppendToBitmap(true);
+}
+
+void Decimal64Builder::UnsafeAppend(std::string_view value) {
+  FixedSizeBinaryBuilder::UnsafeAppend(value);
+}
+
+Status Decimal64Builder::FinishInternal(std::shared_ptr<ArrayData>* out) {
+  std::shared_ptr<Buffer> data;
+  RETURN_NOT_OK(byte_builder_.Finish(&data));
+  std::shared_ptr<Buffer> null_bitmap;
+  RETURN_NOT_OK(null_bitmap_builder_.Finish(&null_bitmap));
+
+  *out = ArrayData::Make(type(), length_, {null_bitmap, data}, null_count_);
+  capacity_ = length_ = null_count_ = 0;
+  return Status::OK();
+}
+
 // ----------------------------------------------------------------------
 // Decimal128Builder
 
diff --git a/cpp/src/arrow/array/builder_decimal.h b/cpp/src/arrow/array/builder_decimal.h
index 8094250aef8d4..a0bf0a0422084 100644
--- a/cpp/src/arrow/array/builder_decimal.h
+++ b/cpp/src/arrow/array/builder_decimal.h
@@ -33,6 +33,68 @@ namespace arrow {
 ///
 /// @{
 
+class ARROW_EXPORT Decimal32Builder : public FixedSizeBinaryBuilder {
+ public:
+  using TypeClass = Decimal32Type;
+  using ValueType = Decimal32;
+
+  explicit Decimal32Builder(const std::shared_ptr<DataType>& type,
+                            MemoryPool* pool = default_memory_pool(),
+                            int64_t alignment = kDefaultBufferAlignment);
+
+  using FixedSizeBinaryBuilder::Append;
+  using FixedSizeBinaryBuilder::AppendValues;
+  using FixedSizeBinaryBuilder::Reset;
+
+  Status Append(Decimal32 val);
+  void UnsafeAppend(Decimal32 val);
+  void UnsafeAppend(std::string_view val);
+
+  Status FinishInternal(std::shared_ptr<ArrayData>* out) override;
+
+  /// \cond FALSE
+  using ArrayBuilder::Finish;
+  /// \endcond
+
+  Status Finish(std::shared_ptr<Decimal32Array>* out) { return FinishTyped(out); }
+
+  std::shared_ptr<DataType> type() const override { return decimal_type_; }
+
+ protected:
+  std::shared_ptr<Decimal32Type> decimal_type_;
+};
+
+class ARROW_EXPORT Decimal64Builder : public FixedSizeBinaryBuilder {
+ public:
+  using TypeClass = Decimal64Type;
+  using ValueType = Decimal64;
+
+  explicit Decimal64Builder(const std::shared_ptr<DataType>& type,
+                            MemoryPool* pool = default_memory_pool(),
+                            int64_t alignment = kDefaultBufferAlignment);
+
+  using FixedSizeBinaryBuilder::Append;
+  using FixedSizeBinaryBuilder::AppendValues;
+  using FixedSizeBinaryBuilder::Reset;
+
+  Status Append(Decimal64 val);
+  void UnsafeAppend(Decimal64 val);
+  void UnsafeAppend(std::string_view val);
+
+  Status FinishInternal(std::shared_ptr<ArrayData>* out) override;
+
+  /// \cond FALSE
+  using ArrayBuilder::Finish;
+  /// \endcond
+
+  Status Finish(std::shared_ptr<Decimal64Array>* out) { return FinishTyped(out); }
+
+  std::shared_ptr<DataType> type() const override { return decimal_type_; }
+
+ protected:
+  std::shared_ptr<Decimal64Type> decimal_type_;
+};
+
 class ARROW_EXPORT Decimal128Builder : public FixedSizeBinaryBuilder {
  public:
   using TypeClass = Decimal128Type;
diff --git a/cpp/src/arrow/array/builder_dict.h b/cpp/src/arrow/array/builder_dict.h
index 3f0d711dc5bb5..116c82049eea9 100644
--- a/cpp/src/arrow/array/builder_dict.h
+++ b/cpp/src/arrow/array/builder_dict.h
@@ -298,20 +298,11 @@ class DictionaryBuilderBase : public ArrayBuilder {
     return Append(std::string_view(value, length));
   }
 
-  /// \brief Append a decimal (only for Decimal128Type)
-  template <typename T1 = T>
-  enable_if_decimal128<T1, Status> Append(const Decimal128& value) {
-    uint8_t data[16];
-    value.ToBytes(data);
-    return Append(data, 16);
-  }
-
-  /// \brief Append a decimal (only for Decimal128Type)
-  template <typename T1 = T>
-  enable_if_decimal256<T1, Status> Append(const Decimal256& value) {
-    uint8_t data[32];
-    value.ToBytes(data);
-    return Append(data, 32);
+  /// \brief Append a decimal (only for Decimal32/64/128/256 Type)
+  template <typename T1 = T, typename CType = typename TypeTraits<T1>::CType>
+  enable_if_decimal<T1, Status> Append(const CType& value) {
+    auto bytes = value.ToBytes();
+    return Append(bytes.data(), static_cast<int32_t>(bytes.size()));
   }
 
   /// \brief Append a scalar null value
diff --git a/cpp/src/arrow/array/concatenate.cc b/cpp/src/arrow/array/concatenate.cc
index b4638dd6593d8..d8a69868d1543 100644
--- a/cpp/src/arrow/array/concatenate.cc
+++ b/cpp/src/arrow/array/concatenate.cc
@@ -377,7 +377,7 @@ class ConcatenateImpl {
   }
 
   Status Visit(const FixedWidthType& fixed) {
-    // Handles numbers, decimal128, decimal256, fixed_size_binary
+    // Handles numbers, decimal32, decimal64, decimal128, decimal256, fixed_size_binary
     ARROW_ASSIGN_OR_RAISE(auto buffers, Buffers(1, fixed));
     return ConcatenateBuffers(buffers, pool_).Value(&out_->buffers[1]);
   }
diff --git a/cpp/src/arrow/array/diff.cc b/cpp/src/arrow/array/diff.cc
index f9714eda34c61..3e36a971578d5 100644
--- a/cpp/src/arrow/array/diff.cc
+++ b/cpp/src/arrow/array/diff.cc
@@ -707,11 +707,9 @@ class MakeFormatterImpl {
   template <typename T>
   enable_if_decimal<T, Status> Visit(const T&) {
     impl_ = [](const Array& array, int64_t index, std::ostream* os) {
-      if constexpr (T::type_id == Type::DECIMAL128) {
-        *os << checked_cast<const Decimal128Array&>(array).FormatValue(index);
-      } else {
-        *os << checked_cast<const Decimal256Array&>(array).FormatValue(index);
-      }
+      const auto& decimal_array =
+          checked_cast<const typename TypeTraits<T>::ArrayType&>(array);
+      *os << decimal_array.FormatValue(index);
     };
     return Status::OK();
   }
diff --git a/cpp/src/arrow/array/diff_test.cc b/cpp/src/arrow/array/diff_test.cc
index 145978a91ad54..02bcf5bbb4c5b 100644
--- a/cpp/src/arrow/array/diff_test.cc
+++ b/cpp/src/arrow/array/diff_test.cc
@@ -707,6 +707,8 @@ TEST_F(DiffTest, UnifiedDiffFormatter) {
   }
 
   for (const auto& type : {
+           decimal32(8, 4),
+           decimal64(10, 4),
            decimal128(10, 4),
            decimal256(10, 4),
        }) {
diff --git a/cpp/src/arrow/array/util.cc b/cpp/src/arrow/array/util.cc
index b56ea25f9e421..51c27b2d9719f 100644
--- a/cpp/src/arrow/array/util.cc
+++ b/cpp/src/arrow/array/util.cc
@@ -152,57 +152,20 @@ class ArrayDataEndianSwapper {
     return Status::OK();
   }
 
-  Status Visit(const Decimal128Type& type) {
-    auto data = reinterpret_cast<const uint64_t*>(data_->buffers[1]->data());
+  template <typename T>
+  enable_if_decimal<T, Status> Visit(const T& type) {
+    using value_type = typename TypeTraits<T>::CType;
+    auto data = data_->buffers[1]->span_as<value_type>();
     ARROW_ASSIGN_OR_RAISE(auto new_buffer,
                           AllocateBuffer(data_->buffers[1]->size(), pool_));
-    auto new_data = reinterpret_cast<uint64_t*>(new_buffer->mutable_data());
-    // NOTE: data_->length not trusted (see warning above)
-    const int64_t length = data_->buffers[1]->size() / Decimal128Type::kByteWidth;
-    for (int64_t i = 0; i < length; i++) {
-      uint64_t tmp;
-      auto idx = i * 2;
-#if ARROW_LITTLE_ENDIAN
-      tmp = bit_util::FromBigEndian(data[idx]);
-      new_data[idx] = bit_util::FromBigEndian(data[idx + 1]);
-      new_data[idx + 1] = tmp;
-#else
-      tmp = bit_util::FromLittleEndian(data[idx]);
-      new_data[idx] = bit_util::FromLittleEndian(data[idx + 1]);
-      new_data[idx + 1] = tmp;
-#endif
-    }
-    out_->buffers[1] = std::move(new_buffer);
-    return Status::OK();
-  }
+    auto new_data = new_buffer->mutable_data_as<value_type>();
 
-  Status Visit(const Decimal256Type& type) {
-    auto data = reinterpret_cast<const uint64_t*>(data_->buffers[1]->data());
-    ARROW_ASSIGN_OR_RAISE(auto new_buffer, AllocateBuffer(data_->buffers[1]->size()));
-    auto new_data = reinterpret_cast<uint64_t*>(new_buffer->mutable_data());
-    // NOTE: data_->length not trusted (see warning above)
-    const int64_t length = data_->buffers[1]->size() / Decimal256Type::kByteWidth;
-    for (int64_t i = 0; i < length; i++) {
-      uint64_t tmp0, tmp1, tmp2;
-      auto idx = i * 4;
-#if ARROW_LITTLE_ENDIAN
-      tmp0 = bit_util::FromBigEndian(data[idx]);
-      tmp1 = bit_util::FromBigEndian(data[idx + 1]);
-      tmp2 = bit_util::FromBigEndian(data[idx + 2]);
-      new_data[idx] = bit_util::FromBigEndian(data[idx + 3]);
-      new_data[idx + 1] = tmp2;
-      new_data[idx + 2] = tmp1;
-      new_data[idx + 3] = tmp0;
-#else
-      tmp0 = bit_util::FromLittleEndian(data[idx]);
-      tmp1 = bit_util::FromLittleEndian(data[idx + 1]);
-      tmp2 = bit_util::FromLittleEndian(data[idx + 2]);
-      new_data[idx] = bit_util::FromLittleEndian(data[idx + 3]);
-      new_data[idx + 1] = tmp2;
-      new_data[idx + 2] = tmp1;
-      new_data[idx + 3] = tmp0;
-#endif
+    for (const value_type& v : data) {
+      auto bytes = v.ToBytes();
+      std::reverse(bytes.begin(), bytes.end());
+      memcpy(new_data++, bytes.data(), bytes.size());
     }
+
     out_->buffers[1] = std::move(new_buffer);
     return Status::OK();
   }
diff --git a/cpp/src/arrow/array/validate.cc b/cpp/src/arrow/array/validate.cc
index 69f1646054f4c..5e466dfa9b2f2 100644
--- a/cpp/src/arrow/array/validate.cc
+++ b/cpp/src/arrow/array/validate.cc
@@ -144,6 +144,16 @@ struct ValidateArrayImpl {
 
   Status Visit(const FixedWidthType&) { return ValidateFixedWidthBuffers(); }
 
+  Status Visit(const Decimal32Type& type) {
+    RETURN_NOT_OK(ValidateFixedWidthBuffers());
+    return ValidateDecimals(type);
+  }
+
+  Status Visit(const Decimal64Type& type) {
+    RETURN_NOT_OK(ValidateFixedWidthBuffers());
+    return ValidateDecimals(type);
+  }
+
   Status Visit(const Decimal128Type& type) {
     RETURN_NOT_OK(ValidateFixedWidthBuffers());
     return ValidateDecimals(type);
diff --git a/cpp/src/arrow/builder.cc b/cpp/src/arrow/builder.cc
index 7042d9818c691..46969e73e22ae 100644
--- a/cpp/src/arrow/builder.cc
+++ b/cpp/src/arrow/builder.cc
@@ -151,6 +151,8 @@ struct DictionaryBuilderCase {
   Status Visit(const BinaryViewType&) { return CreateFor<BinaryViewType>(); }
   Status Visit(const StringViewType&) { return CreateFor<StringViewType>(); }
   Status Visit(const FixedSizeBinaryType&) { return CreateFor<FixedSizeBinaryType>(); }
+  Status Visit(const Decimal32Type&) { return CreateFor<Decimal32Type>(); }
+  Status Visit(const Decimal64Type&) { return CreateFor<Decimal64Type>(); }
   Status Visit(const Decimal128Type&) { return CreateFor<Decimal128Type>(); }
   Status Visit(const Decimal256Type&) { return CreateFor<Decimal256Type>(); }
 
diff --git a/cpp/src/arrow/builder_benchmark.cc b/cpp/src/arrow/builder_benchmark.cc
index 8ec7373a1de1f..3564f0309b756 100644
--- a/cpp/src/arrow/builder_benchmark.cc
+++ b/cpp/src/arrow/builder_benchmark.cc
@@ -228,7 +228,7 @@ static void BuildFixedSizeBinaryArray(
 }
 
 static void BuildDecimalArray(benchmark::State& state) {  // NOLINT non-const reference
-  auto type = decimal(10, 5);
+  auto type = decimal128(10, 5);
   Decimal128 value;
   int32_t precision = 0;
   int32_t scale = 0;
diff --git a/cpp/src/arrow/c/bridge.cc b/cpp/src/arrow/c/bridge.cc
index eba575f4cf39c..4f9095182f90c 100644
--- a/cpp/src/arrow/c/bridge.cc
+++ b/cpp/src/arrow/c/bridge.cc
@@ -1249,13 +1249,20 @@ struct SchemaImporter {
     if (prec_scale[0] <= 0) {
       return f_parser_.Invalid();
     }
-    if (prec_scale.size() == 2 || prec_scale[2] == 128) {
+    if (prec_scale.size() == 2) {
+      type_ = decimal128(prec_scale[0], prec_scale[1]);
+    } else if (prec_scale[2] == 32) {
+      type_ = decimal32(prec_scale[0], prec_scale[1]);
+    } else if (prec_scale[2] == 64) {
+      type_ = decimal64(prec_scale[0], prec_scale[1]);
+    } else if (prec_scale[2] == 128) {
       type_ = decimal128(prec_scale[0], prec_scale[1]);
     } else if (prec_scale[2] == 256) {
       type_ = decimal256(prec_scale[0], prec_scale[1]);
     } else {
       return f_parser_.Invalid();
     }
+
     return Status::OK();
   }
 
diff --git a/cpp/src/arrow/c/bridge_benchmark.cc b/cpp/src/arrow/c/bridge_benchmark.cc
index 1ae4657fc9c0c..cc8a3cb1829c6 100644
--- a/cpp/src/arrow/c/bridge_benchmark.cc
+++ b/cpp/src/arrow/c/bridge_benchmark.cc
@@ -39,7 +39,7 @@ std::shared_ptr<Schema> ExampleSchema() {
   auto f5 = field("f5", float32());
   auto f6 = field("f6", float32());
   auto f7 = field("f7", float32());
-  auto f8 = field("f8", decimal(19, 10));
+  auto f8 = field("f8", decimal128(19, 10));
   return schema({f0, f1, f2, f3, f4, f5, f6, f7, f8});
 }
 
diff --git a/cpp/src/arrow/c/bridge_test.cc b/cpp/src/arrow/c/bridge_test.cc
index 01fd56f631d99..fdcb53ddbcfb5 100644
--- a/cpp/src/arrow/c/bridge_test.cc
+++ b/cpp/src/arrow/c/bridge_test.cc
@@ -363,13 +363,19 @@ TEST_F(TestSchemaExport, Primitive) {
   TestPrimitive(binary_view(), "vz");
   TestPrimitive(utf8_view(), "vu");
 
-  TestPrimitive(decimal(16, 4), "d:16,4");
+  TestPrimitive(smallest_decimal(8, 4), "d:8,4,32");
+  TestPrimitive(smallest_decimal(16, 4), "d:16,4,64");
+  TestPrimitive(decimal128(16, 4), "d:16,4");
   TestPrimitive(decimal256(16, 4), "d:16,4,256");
 
-  TestPrimitive(decimal(15, 0), "d:15,0");
+  TestPrimitive(smallest_decimal(8, 0), "d:8,0,32");
+  TestPrimitive(smallest_decimal(15, 0), "d:15,0,64");
+  TestPrimitive(decimal128(15, 0), "d:15,0");
   TestPrimitive(decimal256(15, 0), "d:15,0,256");
 
-  TestPrimitive(decimal(15, -4), "d:15,-4");
+  TestPrimitive(smallest_decimal(8, -4), "d:8,-4,32");
+  TestPrimitive(smallest_decimal(15, -4), "d:15,-4,64");
+  TestPrimitive(decimal128(15, -4), "d:15,-4");
   TestPrimitive(decimal256(15, -4), "d:15,-4,256");
 }
 
@@ -906,7 +912,9 @@ TEST_F(TestArrayExport, Primitive) {
   TestPrimitive(binary_view(), R"(["foo", "bar", null])");
   TestPrimitive(utf8_view(), R"(["foo", "bar", null])");
 
-  TestPrimitive(decimal(16, 4), R"(["1234.5670", null])");
+  TestPrimitive(decimal32(9, 4), R"(["1234.5670", null])");
+  TestPrimitive(decimal64(16, 4), R"(["1234.5670", null])");
+  TestPrimitive(decimal128(16, 4), R"(["1234.5670", null])");
   TestPrimitive(decimal256(16, 4), R"(["1234.5670", null])");
 
   TestPrimitive(month_day_nano_interval(), R"([[-1, 5, 20], null])");
@@ -1501,7 +1509,9 @@ TEST_F(TestDeviceArrayExport, Primitive) {
   TestPrimitive(mm, utf8(), R"(["foo", "bar", null])");
   TestPrimitive(mm, large_utf8(), R"(["foo", "bar", null])");
 
-  TestPrimitive(mm, decimal(16, 4), R"(["1234.5670", null])");
+  TestPrimitive(mm, decimal32(9, 4), R"(["1234.5670", null])");
+  TestPrimitive(mm, decimal64(16, 4), R"(["1234.5670", null])");
+  TestPrimitive(mm, decimal128(16, 4), R"(["1234.5670", null])");
   TestPrimitive(mm, decimal256(16, 4), R"(["1234.5670", null])");
 
   TestPrimitive(mm, month_day_nano_interval(), R"([[-1, 5, 20], null])");
@@ -1951,6 +1961,10 @@ TEST_F(TestSchemaImport, Primitive) {
   CheckImport(field("", decimal128(16, 4)));
   FillPrimitive("d:16,4,256");
   CheckImport(field("", decimal256(16, 4)));
+  FillPrimitive("d:4,4,32");
+  CheckImport(field("", decimal32(4, 4)));
+  FillPrimitive("d:16,4,64");
+  CheckImport(field("", decimal64(16, 4)));
 
   FillPrimitive("d:16,0");
   CheckImport(field("", decimal128(16, 0)));
@@ -1958,6 +1972,10 @@ TEST_F(TestSchemaImport, Primitive) {
   CheckImport(field("", decimal128(16, 0)));
   FillPrimitive("d:16,0,256");
   CheckImport(field("", decimal256(16, 0)));
+  FillPrimitive("d:4,0,32");
+  CheckImport(field("", decimal32(4, 0)));
+  FillPrimitive("d:16,0,64");
+  CheckImport(field("", decimal64(16, 0)));
 
   FillPrimitive("d:16,-4");
   CheckImport(field("", decimal128(16, -4)));
@@ -1965,6 +1983,10 @@ TEST_F(TestSchemaImport, Primitive) {
   CheckImport(field("", decimal128(16, -4)));
   FillPrimitive("d:16,-4,256");
   CheckImport(field("", decimal256(16, -4)));
+  FillPrimitive("d:4,-4,32");
+  CheckImport(field("", decimal32(4, -4)));
+  FillPrimitive("d:16,-4,64");
+  CheckImport(field("", decimal64(16, -4)));
 }
 
 TEST_F(TestSchemaImport, Temporal) {
@@ -2034,7 +2056,7 @@ TEST_F(TestSchemaImport, String) {
   FillPrimitive("w:3");
   CheckImport(fixed_size_binary(3));
   FillPrimitive("d:15,4");
-  CheckImport(decimal(15, 4));
+  CheckImport(decimal128(15, 4));
 }
 
 TEST_F(TestSchemaImport, List) {
@@ -2950,26 +2972,26 @@ TEST_F(TestArrayImport, FixedSizeBinary) {
   FillPrimitive(2, 0, 0, primitive_buffers_no_nulls2);
   CheckImport(ArrayFromJSON(fixed_size_binary(3), R"(["abc", "def"])"));
   FillPrimitive(2, 0, 0, primitive_buffers_no_nulls3);
-  CheckImport(ArrayFromJSON(decimal(15, 4), R"(["12345.6789", "98765.4321"])"));
+  CheckImport(ArrayFromJSON(decimal128(15, 4), R"(["12345.6789", "98765.4321"])"));
 
   // Empty array with null data pointers
   FillPrimitive(0, 0, 0, all_buffers_omitted);
   CheckImport(ArrayFromJSON(fixed_size_binary(3), "[]"));
   FillPrimitive(0, 0, 0, all_buffers_omitted);
-  CheckImport(ArrayFromJSON(decimal(15, 4), "[]"));
+  CheckImport(ArrayFromJSON(decimal128(15, 4), "[]"));
 }
 
 TEST_F(TestArrayImport, FixedSizeBinaryWithOffset) {
   FillPrimitive(1, 0, 1, primitive_buffers_no_nulls2);
   CheckImport(ArrayFromJSON(fixed_size_binary(3), R"(["def"])"));
   FillPrimitive(1, 0, 1, primitive_buffers_no_nulls3);
-  CheckImport(ArrayFromJSON(decimal(15, 4), R"(["98765.4321"])"));
+  CheckImport(ArrayFromJSON(decimal128(15, 4), R"(["98765.4321"])"));
 
   // Empty array with null data pointers
   FillPrimitive(0, 0, 1, all_buffers_omitted);
   CheckImport(ArrayFromJSON(fixed_size_binary(3), "[]"));
   FillPrimitive(0, 0, 1, all_buffers_omitted);
-  CheckImport(ArrayFromJSON(decimal(15, 4), "[]"));
+  CheckImport(ArrayFromJSON(decimal128(15, 4), "[]"));
 }
 
 TEST_F(TestArrayImport, List) {
@@ -3624,10 +3646,16 @@ TEST_F(TestSchemaRoundtrip, Primitive) {
   TestWithTypeFactory(boolean);
   TestWithTypeFactory(float16);
 
+  TestWithTypeFactory([] { return decimal32(8, 4); });
+  TestWithTypeFactory([] { return decimal64(16, 4); });
   TestWithTypeFactory([] { return decimal128(19, 4); });
   TestWithTypeFactory([] { return decimal256(19, 4); });
+  TestWithTypeFactory([] { return decimal32(8, 0); });
+  TestWithTypeFactory([] { return decimal64(16, 0); });
   TestWithTypeFactory([] { return decimal128(19, 0); });
   TestWithTypeFactory([] { return decimal256(19, 0); });
+  TestWithTypeFactory([] { return decimal32(8, -5); });
+  TestWithTypeFactory([] { return decimal64(16, -5); });
   TestWithTypeFactory([] { return decimal128(19, -5); });
   TestWithTypeFactory([] { return decimal256(19, -5); });
   TestWithTypeFactory([] { return fixed_size_binary(3); });
@@ -3661,7 +3689,7 @@ TEST_F(TestSchemaRoundtrip, ListView) {
 
 TEST_F(TestSchemaRoundtrip, Struct) {
   auto f1 = field("f1", utf8(), /*nullable=*/false);
-  auto f2 = field("f2", list(decimal(19, 4)));
+  auto f2 = field("f2", list(decimal128(19, 4)));
 
   TestWithTypeFactory([&]() { return struct_({f1, f2}); });
   f2 = f2->WithMetadata(key_value_metadata(kMetadataKeys2, kMetadataValues2));
@@ -3671,7 +3699,7 @@ TEST_F(TestSchemaRoundtrip, Struct) {
 
 TEST_F(TestSchemaRoundtrip, Union) {
   auto f1 = field("f1", utf8(), /*nullable=*/false);
-  auto f2 = field("f2", list(decimal(19, 4)));
+  auto f2 = field("f2", list(decimal128(19, 4)));
   auto type_codes = std::vector<int8_t>{42, 43};
 
   TestWithTypeFactory(
@@ -3901,6 +3929,8 @@ TEST_F(TestArrayRoundtrip, Primitive) {
   TestWithJSON(int32(), "[]");
   TestWithJSON(int32(), "[4, 5, null]");
 
+  TestWithJSON(decimal32(8, 4), R"(["0.4759", "1234.5670", null])");
+  TestWithJSON(decimal64(16, 4), R"(["0.4759", "1234.5670", null])");
   TestWithJSON(decimal128(16, 4), R"(["0.4759", "1234.5670", null])");
   TestWithJSON(decimal256(16, 4), R"(["0.4759", "1234.5670", null])");
 
@@ -3908,6 +3938,8 @@ TEST_F(TestArrayRoundtrip, Primitive) {
 
   TestWithJSONSliced(int32(), "[4, 5]");
   TestWithJSONSliced(int32(), "[4, 5, 6, null]");
+  TestWithJSONSliced(decimal32(8, 4), R"(["0.4759", "1234.5670", null])");
+  TestWithJSONSliced(decimal64(16, 4), R"(["0.4759", "1234.5670", null])");
   TestWithJSONSliced(decimal128(16, 4), R"(["0.4759", "1234.5670", null])");
   TestWithJSONSliced(decimal256(16, 4), R"(["0.4759", "1234.5670", null])");
   TestWithJSONSliced(month_day_nano_interval(),
diff --git a/cpp/src/arrow/compare.cc b/cpp/src/arrow/compare.cc
index e983b47e39dc4..23a921cc5a0a4 100644
--- a/cpp/src/arrow/compare.cc
+++ b/cpp/src/arrow/compare.cc
@@ -750,15 +750,10 @@ class TypeEqualsVisitor {
     return Status::OK();
   }
 
-  Status Visit(const Decimal128Type& left) {
-    const auto& right = checked_cast<const Decimal128Type&>(right_);
-    result_ = left.precision() == right.precision() && left.scale() == right.scale();
-    return Status::OK();
-  }
-
-  Status Visit(const Decimal256Type& left) {
-    const auto& right = checked_cast<const Decimal256Type&>(right_);
-    result_ = left.precision() == right.precision() && left.scale() == right.scale();
+  Status Visit(const DecimalType& left) {
+    const auto& right = checked_cast<const DecimalType&>(right_);
+    result_ = left.byte_width() == right.byte_width() &&
+              left.precision() == right.precision() && left.scale() == right.scale();
     return Status::OK();
   }
 
@@ -900,6 +895,18 @@ class ScalarEqualsVisitor {
     return Status::OK();
   }
 
+  Status Visit(const Decimal32Scalar& left) {
+    const auto& right = checked_cast<const Decimal32Scalar&>(right_);
+    result_ = left.value == right.value;
+    return Status::OK();
+  }
+
+  Status Visit(const Decimal64Scalar& left) {
+    const auto& right = checked_cast<const Decimal64Scalar&>(right_);
+    result_ = left.value == right.value;
+    return Status::OK();
+  }
+
   Status Visit(const Decimal128Scalar& left) {
     const auto& right = checked_cast<const Decimal128Scalar&>(right_);
     result_ = left.value == right.value;
diff --git a/cpp/src/arrow/compute/kernel_test.cc b/cpp/src/arrow/compute/kernel_test.cc
index 5daf7d2991d2a..e9664b104d7a6 100644
--- a/cpp/src/arrow/compute/kernel_test.cc
+++ b/cpp/src/arrow/compute/kernel_test.cc
@@ -36,7 +36,7 @@ namespace compute {
 
 TEST(TypeMatcher, SameTypeId) {
   std::shared_ptr<TypeMatcher> matcher = match::SameTypeId(Type::DECIMAL);
-  ASSERT_TRUE(matcher->Matches(*decimal(12, 2)));
+  ASSERT_TRUE(matcher->Matches(*decimal128(20, 2)));
   ASSERT_FALSE(matcher->Matches(*int8()));
 
   ASSERT_EQ("Type::DECIMAL128", matcher->ToString());
@@ -120,7 +120,7 @@ TEST(InputType, Constructors) {
   InputType ty2(Type::DECIMAL);
   ASSERT_EQ(InputType::USE_TYPE_MATCHER, ty2.kind());
   ASSERT_EQ("Type::DECIMAL128", ty2.ToString());
-  ASSERT_TRUE(ty2.type_matcher().Matches(*decimal(12, 2)));
+  ASSERT_TRUE(ty2.type_matcher().Matches(*decimal128(12, 2)));
   ASSERT_FALSE(ty2.type_matcher().Matches(*int16()));
 
   // Implicit construction in a vector
@@ -204,9 +204,9 @@ TEST(InputType, Matches) {
   ASSERT_FALSE(input1.Matches(*int16()));
 
   InputType input2(Type::DECIMAL);
-  ASSERT_TRUE(input2.Matches(*decimal(12, 2)));
+  ASSERT_TRUE(input2.Matches(*decimal128(12, 2)));
 
-  auto ty2 = decimal(12, 2);
+  auto ty2 = decimal128(12, 2);
   auto ty3 = float64();
   ASSERT_OK_AND_ASSIGN(std::shared_ptr<Array> arr2, MakeArrayOfNull(ty2, 1));
   ASSERT_OK_AND_ASSIGN(std::shared_ptr<Array> arr3, MakeArrayOfNull(ty3, 1));
@@ -319,7 +319,7 @@ TEST(KernelSignature, Basics) {
   ASSERT_EQ(2, sig.in_types().size());
   ASSERT_TRUE(sig.in_types()[0].type()->Equals(*int8()));
   ASSERT_TRUE(sig.in_types()[0].Matches(*int8()));
-  ASSERT_TRUE(sig.in_types()[1].Matches(*decimal(12, 2)));
+  ASSERT_TRUE(sig.in_types()[1].Matches(*decimal128(12, 2)));
 }
 
 TEST(KernelSignature, Equals) {
@@ -381,7 +381,7 @@ TEST(KernelSignature, MatchesInputs) {
 
   ASSERT_FALSE(sig2.MatchesInputs({}));
   ASSERT_FALSE(sig2.MatchesInputs({int8()}));
-  ASSERT_TRUE(sig2.MatchesInputs({int8(), decimal(12, 2)}));
+  ASSERT_TRUE(sig2.MatchesInputs({int8(), decimal128(12, 2)}));
 
   // (int8, int32) -> boolean
   KernelSignature sig3({int8(), int32()}, boolean());
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index b545d8bcc1003..68b1ac7c03ca8 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -336,8 +336,8 @@ struct ProductImpl : public ScalarAggregator {
       internal::VisitArrayValuesInline<ArrowType>(
           data,
           [&](typename TypeTraits<ArrowType>::CType value) {
-            this->product =
-                MultiplyTraits<AccType>::Multiply(*out_type, this->product, value);
+            this->product = MultiplyTraits<AccType>::Multiply(
+                *out_type, this->product, static_cast<ProductType>(value));
           },
           [] {});
     } else {
@@ -347,8 +347,8 @@ struct ProductImpl : public ScalarAggregator {
       if (data.is_valid) {
         for (int64_t i = 0; i < batch.length; i++) {
           auto value = internal::UnboxScalar<ArrowType>::Unbox(data);
-          this->product =
-              MultiplyTraits<AccType>::Multiply(*out_type, this->product, value);
+          this->product = MultiplyTraits<AccType>::Multiply(
+              *out_type, this->product, static_cast<ProductType>(value));
         }
       }
     }
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.inc.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.inc.cc
index f2151e0a9e029..49010d182cd6d 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.inc.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.inc.cc
@@ -77,7 +77,8 @@ struct SumImpl : public ScalarAggregator {
       this->count += data.is_valid * batch.length;
       this->nulls_observed = this->nulls_observed || !data.is_valid;
       if (data.is_valid) {
-        this->sum += internal::UnboxScalar<ArrowType>::Unbox(data) * batch.length;
+        this->sum += static_cast<SumCType>(internal::UnboxScalar<ArrowType>::Unbox(data) *
+                                           batch.length);
       }
     }
     return Status::OK();
diff --git a/cpp/src/arrow/compute/kernels/aggregate_internal.h b/cpp/src/arrow/compute/kernels/aggregate_internal.h
index 168f063c770f3..9dab049821d5c 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_internal.h
@@ -52,6 +52,16 @@ struct FindAccumulatorType<I, enable_if_floating_point<I>> {
   using Type = DoubleType;
 };
 
+template <typename I>
+struct FindAccumulatorType<I, enable_if_decimal32<I>> {
+  using Type = Decimal32Type;
+};
+
+template <typename I>
+struct FindAccumulatorType<I, enable_if_decimal64<I>> {
+  using Type = Decimal64Type;
+};
+
 template <typename I>
 struct FindAccumulatorType<I, enable_if_decimal128<I>> {
   using Type = Decimal128Type;
diff --git a/cpp/src/arrow/compute/kernels/aggregate_tdigest.cc b/cpp/src/arrow/compute/kernels/aggregate_tdigest.cc
index 1dab92632ef2d..83d01091b3c8d 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_tdigest.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_tdigest.cc
@@ -51,6 +51,8 @@ struct TDigestImpl : public ScalarAggregator {
   double ToDouble(T value) const {
     return static_cast<double>(value);
   }
+  double ToDouble(const Decimal32& value) const { return value.ToDouble(decimal_scale); }
+  double ToDouble(const Decimal64& value) const { return value.ToDouble(decimal_scale); }
   double ToDouble(const Decimal128& value) const { return value.ToDouble(decimal_scale); }
   double ToDouble(const Decimal256& value) const { return value.ToDouble(decimal_scale); }
 
diff --git a/cpp/src/arrow/compute/kernels/aggregate_var_std.cc b/cpp/src/arrow/compute/kernels/aggregate_var_std.cc
index c2fab48dbe208..e4189f9b62b17 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_var_std.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_var_std.cc
@@ -46,6 +46,8 @@ struct VarStdState {
   double ToDouble(T value) const {
     return static_cast<double>(value);
   }
+  double ToDouble(const Decimal32& value) const { return value.ToDouble(decimal_scale); }
+  double ToDouble(const Decimal64& value) const { return value.ToDouble(decimal_scale); }
   double ToDouble(const Decimal128& value) const { return value.ToDouble(decimal_scale); }
   double ToDouble(const Decimal256& value) const { return value.ToDouble(decimal_scale); }
 
@@ -53,8 +55,9 @@ struct VarStdState {
   // algorithm`
   // https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Two-pass_algorithm
   template <typename T = ArrowType>
-  enable_if_t<is_floating_type<T>::value || (sizeof(CType) > 4)> Consume(
-      const ArraySpan& array) {
+  enable_if_t<is_floating_type<T>::value || (sizeof(CType) > 4) ||
+              (!is_integer_type<T>::value && sizeof(CType) == 4)>
+  Consume(const ArraySpan& array) {
     this->all_valid = array.GetNullCount() == 0;
     int64_t count = array.length - array.GetNullCount();
     if (count == 0 || (!this->all_valid && !options.skip_nulls)) {
diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index 7f9be92f3a14b..594bd1fce0b84 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -141,6 +141,30 @@ struct GetViewType<Type, enable_if_t<is_base_binary_type<Type>::value ||
   static T LogicalValue(PhysicalType value) { return value; }
 };
 
+template <>
+struct GetViewType<Decimal32Type> {
+  using T = Decimal32;
+  using PhysicalType = std::string_view;
+
+  static T LogicalValue(PhysicalType value) {
+    return Decimal32(reinterpret_cast<const uint8_t*>(value.data()));
+  }
+
+  static T LogicalValue(T value) { return value; }
+};
+
+template <>
+struct GetViewType<Decimal64Type> {
+  using T = Decimal64;
+  using PhysicalType = std::string_view;
+
+  static T LogicalValue(PhysicalType value) {
+    return Decimal64(reinterpret_cast<const uint8_t*>(value.data()));
+  }
+
+  static T LogicalValue(T value) { return value; }
+};
+
 template <>
 struct GetViewType<Decimal128Type> {
   using T = Decimal128;
@@ -178,6 +202,16 @@ struct GetOutputType<Type, enable_if_t<is_string_like_type<Type>::value>> {
   using T = std::string;
 };
 
+template <>
+struct GetOutputType<Decimal32Type> {
+  using T = Decimal32;
+};
+
+template <>
+struct GetOutputType<Decimal64Type> {
+  using T = Decimal64;
+};
+
 template <>
 struct GetOutputType<Decimal128Type> {
   using T = Decimal128;
@@ -225,7 +259,9 @@ using enable_if_not_floating_value = enable_if_t<!std::is_floating_point<T>::val
 
 template <typename T, typename R = T>
 using enable_if_decimal_value =
-    enable_if_t<std::is_same<Decimal128, T>::value || std::is_same<Decimal256, T>::value,
+    enable_if_t<std::is_same<Decimal32, T>::value || std::is_same<Decimal64, T>::value ||
+                    std::is_same<Decimal128, T>::value ||
+                    std::is_same<Decimal256, T>::value,
                 R>;
 
 // ----------------------------------------------------------------------
@@ -354,6 +390,22 @@ struct UnboxScalar<Type, enable_if_has_string_view<Type>> {
   }
 };
 
+template <>
+struct UnboxScalar<Decimal32Type> {
+  using T = Decimal32;
+  static const T& Unbox(const Scalar& val) {
+    return checked_cast<const Decimal32Scalar&>(val).value;
+  }
+};
+
+template <>
+struct UnboxScalar<Decimal64Type> {
+  using T = Decimal64;
+  static const T& Unbox(const Scalar& val) {
+    return checked_cast<const Decimal64Scalar&>(val).value;
+  }
+};
+
 template <>
 struct UnboxScalar<Decimal128Type> {
   using T = Decimal128;
@@ -1117,6 +1169,10 @@ ArrayKernelExec GeneratePhysicalNumeric(detail::GetTypeId get_id) {
 template <template <typename... Args> class Generator, typename... Args>
 ArrayKernelExec GenerateDecimalToDecimal(detail::GetTypeId get_id) {
   switch (get_id.id) {
+    case Type::DECIMAL32:
+      return Generator<Decimal32Type, Args...>::Exec;
+    case Type::DECIMAL64:
+      return Generator<Decimal64Type, Args...>::Exec;
     case Type::DECIMAL128:
       return Generator<Decimal128Type, Args...>::Exec;
     case Type::DECIMAL256:
@@ -1312,6 +1368,10 @@ ArrayKernelExec GenerateTemporal(detail::GetTypeId get_id) {
 template <template <typename...> class Generator, typename Type0, typename... Args>
 ArrayKernelExec GenerateDecimal(detail::GetTypeId get_id) {
   switch (get_id.id) {
+    case Type::DECIMAL32:
+      return Generator<Type0, Decimal32Type, Args...>::Exec;
+    case Type::DECIMAL64:
+      return Generator<Type0, Decimal64Type, Args...>::Exec;
     case Type::DECIMAL128:
       return Generator<Type0, Decimal128Type, Args...>::Exec;
     case Type::DECIMAL256:
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate.cc b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
index 1207355939a0c..21b7bd9bf6632 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate.cc
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
@@ -477,7 +477,7 @@ struct GroupedReducingAggregator : public GroupedAggregator {
     VisitGroupedValues<Type>(
         batch,
         [&](uint32_t g, InputCType value) {
-          reduced[g] = Impl::Reduce(*out_type_, reduced[g], value);
+          reduced[g] = Impl::Reduce(*out_type_, reduced[g], static_cast<CType>(value));
           counts[g]++;
         },
         [&](uint32_t g) { bit_util::SetBitTo(no_nulls, g, false); });
@@ -880,6 +880,8 @@ struct GroupedVarStdImpl : public GroupedAggregator {
   double ToDouble(T value) const {
     return static_cast<double>(value);
   }
+  double ToDouble(const Decimal32& value) const { return value.ToDouble(decimal_scale_); }
+  double ToDouble(const Decimal64& value) const { return value.ToDouble(decimal_scale_); }
   double ToDouble(const Decimal128& value) const {
     return value.ToDouble(decimal_scale_);
   }
@@ -892,8 +894,10 @@ struct GroupedVarStdImpl : public GroupedAggregator {
   // float/double/int64/decimal: calculate `m2` (sum((X-mean)^2)) with
   // `two pass algorithm` (see aggregate_var_std.cc)
   template <typename T = Type>
-  enable_if_t<is_floating_type<T>::value || (sizeof(CType) > 4), Status> ConsumeImpl(
-      const ExecSpan& batch) {
+  enable_if_t<is_floating_type<T>::value || (sizeof(CType) > 4) ||
+                  std::is_same_v<CType, Decimal32>,
+              Status>
+  ConsumeImpl(const ExecSpan& batch) {
     using SumType = typename internal::GetSumType<T>::SumType;
 
     GroupedVarStdImpl<Type> state;
@@ -910,7 +914,7 @@ struct GroupedVarStdImpl : public GroupedAggregator {
     VisitGroupedValues<Type>(
         batch,
         [&](uint32_t g, typename TypeTraits<Type>::CType value) {
-          sums[g] += value;
+          sums[g] += static_cast<SumType>(value);
           counts[g]++;
         },
         [&](uint32_t g) { bit_util::ClearBit(no_nulls, g); });
@@ -1186,6 +1190,8 @@ struct GroupedTDigestImpl : public GroupedAggregator {
   double ToDouble(T value) const {
     return static_cast<double>(value);
   }
+  double ToDouble(const Decimal32& value) const { return value.ToDouble(decimal_scale_); }
+  double ToDouble(const Decimal64& value) const { return value.ToDouble(decimal_scale_); }
   double ToDouble(const Decimal128& value) const {
     return value.ToDouble(decimal_scale_);
   }
@@ -1365,6 +1371,18 @@ struct AntiExtrema<double> {
   static constexpr double anti_max() { return -std::numeric_limits<double>::infinity(); }
 };
 
+template <>
+struct AntiExtrema<Decimal32> {
+  static constexpr Decimal32 anti_min() { return BasicDecimal32::GetMaxSentinel(); }
+  static constexpr Decimal32 anti_max() { return BasicDecimal32::GetMinSentinel(); }
+};
+
+template <>
+struct AntiExtrema<Decimal64> {
+  static constexpr Decimal64 anti_min() { return BasicDecimal64::GetMaxSentinel(); }
+  static constexpr Decimal64 anti_max() { return BasicDecimal64::GetMinSentinel(); }
+};
+
 template <>
 struct AntiExtrema<Decimal128> {
   static constexpr Decimal128 anti_min() { return BasicDecimal128::GetMaxSentinel(); }
diff --git a/cpp/src/arrow/compute/kernels/vector_hash_test.cc b/cpp/src/arrow/compute/kernels/vector_hash_test.cc
index c4ec74fbaabca..7f2325d4ffc41 100644
--- a/cpp/src/arrow/compute/kernels/vector_hash_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_hash_test.cc
@@ -616,7 +616,7 @@ TEST_F(TestHashKernel, UniqueDecimal) {
   std::vector<Decimal128> values{12, 12, 11, 12};
   std::vector<Decimal128> expected{12, 0, 11};
 
-  CheckUnique<Decimal128Type, Decimal128>(decimal(2, 0), values,
+  CheckUnique<Decimal128Type, Decimal128>(decimal128(2, 0), values,
                                           {true, false, true, true}, expected, {1, 0, 1});
 }
 
@@ -630,15 +630,16 @@ TEST_F(TestHashKernel, ValueCountsDecimal) {
   std::vector<Decimal128> values{12, 12, 11, 12};
   std::vector<Decimal128> expected{12, 0, 11};
 
-  CheckValueCounts<Decimal128Type, Decimal128>(
-      decimal(2, 0), values, {true, false, true, true}, expected, {1, 0, 1}, {2, 1, 1});
+  CheckValueCounts<Decimal128Type, Decimal128>(decimal128(2, 0), values,
+                                               {true, false, true, true}, expected,
+                                               {1, 0, 1}, {2, 1, 1});
 }
 
 TEST_F(TestHashKernel, DictEncodeDecimal) {
   std::vector<Decimal128> values{12, 12, 11, 12, 13};
   std::vector<Decimal128> expected{12, 11, 13};
 
-  CheckDictEncode<Decimal128Type, Decimal128>(decimal(2, 0), values,
+  CheckDictEncode<Decimal128Type, Decimal128>(decimal128(2, 0), values,
                                               {true, false, true, true, true}, expected,
                                               {}, {0, 0, 1, 0, 2});
 }
diff --git a/cpp/src/arrow/compute/kernels/vector_pairwise_test.cc b/cpp/src/arrow/compute/kernels/vector_pairwise_test.cc
index c77f8ecc1a403..8cac602dc1608 100644
--- a/cpp/src/arrow/compute/kernels/vector_pairwise_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_pairwise_test.cc
@@ -68,7 +68,7 @@ class TestPairwiseDiff : public ::testing::Test {
   void SetUp() override {
     test_numerical_types_ = NumericTypes();
     test_temporal_types_ = TemporalTypes();
-    test_decimal_types_ = {decimal(4, 2), decimal(70, 10)};
+    test_decimal_types_ = {decimal128(4, 2), decimal256(70, 10)};
 
     test_input_types_.insert(test_input_types_.end(), test_numerical_types_.begin(),
                              test_numerical_types_.end());
@@ -188,24 +188,26 @@ TEST_F(TestPairwiseDiff, Temporal) {
 TEST_F(TestPairwiseDiff, Decimal) {
   {
     PairwiseOptions options(1);
-    auto input = ArrayFromJSON(decimal(4, 2), R"(["11.00", "22.11", "-10.25", "33.45"])");
-    auto output = ArrayFromJSON(decimal(5, 2), R"([null, "11.11", "-32.36", "43.70"])");
+    auto input =
+        ArrayFromJSON(decimal128(4, 2), R"(["11.00", "22.11", "-10.25", "33.45"])");
+    auto output =
+        ArrayFromJSON(decimal128(5, 2), R"([null, "11.11", "-32.36", "43.70"])");
     CheckVectorUnary("pairwise_diff", input, output, &options);
   }
 
   {
     PairwiseOptions options(-1);
     auto input = ArrayFromJSON(
-        decimal(40, 30),
+        decimal256(40, 30),
         R"(["1111111111.222222222222222222222222222222", "2222222222.333333333333333333333333333333"])");
     auto output = ArrayFromJSON(
-        decimal(41, 30), R"(["-1111111111.111111111111111111111111111111", null])");
+        decimal256(41, 30), R"(["-1111111111.111111111111111111111111111111", null])");
     CheckVectorUnary("pairwise_diff", input, output, &options);
   }
 
   {  /// Out of range decimal precision
     PairwiseOptions options(1);
-    auto input = ArrayFromJSON(decimal(38, 0), R"(["1e38"])");
+    auto input = ArrayFromJSON(decimal128(38, 0), R"(["1e38"])");
 
     EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid,
                                     testing::HasSubstr("Decimal precision out of range"),
diff --git a/cpp/src/arrow/csv/converter_benchmark.cc b/cpp/src/arrow/csv/converter_benchmark.cc
index 8cd771a7dafde..342a339a8c130 100644
--- a/cpp/src/arrow/csv/converter_benchmark.cc
+++ b/cpp/src/arrow/csv/converter_benchmark.cc
@@ -122,7 +122,7 @@ static void Decimal128Conversion(benchmark::State& state) {  // NOLINT non-const
   auto parser = BuildDecimal128Data(num_rows);
   auto options = ConvertOptions::Defaults();
 
-  BenchmarkConversion(state, *parser, decimal(24, 9), options);
+  BenchmarkConversion(state, *parser, decimal128(24, 9), options);
 }
 
 static void StringConversion(benchmark::State& state) {  // NOLINT non-const reference
diff --git a/cpp/src/arrow/csv/converter_test.cc b/cpp/src/arrow/csv/converter_test.cc
index 657e8d813ca1b..3e220c11ad6b1 100644
--- a/cpp/src/arrow/csv/converter_test.cc
+++ b/cpp/src/arrow/csv/converter_test.cc
@@ -670,32 +670,32 @@ Decimal128 Dec128(std::string_view value) {
 
 TEST(DecimalConversion, Basics) {
   AssertConversion<Decimal128Type, Decimal128>(
-      decimal(23, 2), {"12,34.5\n", "36.37,-1e5\n"},
+      decimal128(23, 2), {"12,34.5\n", "36.37,-1e5\n"},
       {{Dec128("12.00"), Dec128("36.37")}, {Dec128("34.50"), Dec128("-100000.00")}});
 }
 
 TEST(DecimalConversion, Nulls) {
   AssertConversion<Decimal128Type, Decimal128>(
-      decimal(14, 3), {"1.5,0.\n", ",-1e3\n"},
+      decimal128(14, 3), {"1.5,0.\n", ",-1e3\n"},
       {{Dec128("1.500"), Decimal128()}, {Decimal128(), Dec128("-1000.000")}},
       {{true, false}, {true, true}});
 
-  AssertConversionAllNulls<Decimal128Type, Decimal128>(decimal(14, 2));
+  AssertConversionAllNulls<Decimal128Type, Decimal128>(decimal128(14, 2));
 }
 
 TEST(DecimalConversion, CustomNulls) {
   auto options = ConvertOptions::Defaults();
   options.null_values = {"xxx", "zzz"};
 
-  AssertConversion<Decimal128Type, Decimal128>(decimal(14, 3), {"\"1.5\",\"xxx\"\n"},
+  AssertConversion<Decimal128Type, Decimal128>(decimal128(14, 3), {"\"1.5\",\"xxx\"\n"},
                                                {{Dec128("1.500")}, {0}},
                                                {{true}, {false}}, options);
 
   options.quoted_strings_can_be_null = false;
-  AssertConversionError(decimal(14, 3), {"\"1.5\",\"xxx\"\n"}, {1}, options);
+  AssertConversionError(decimal128(14, 3), {"\"1.5\",\"xxx\"\n"}, {1}, options);
 
   AssertConversion<Decimal128Type, Decimal128>(
-      decimal(14, 3), {"1.5,xxx\n", "zzz,-1e3\n"},
+      decimal128(14, 3), {"1.5,xxx\n", "zzz,-1e3\n"},
       {{Dec128("1.500"), Decimal128()}, {Decimal128(), Dec128("-1000.000")}},
       {{true, false}, {false, true}}, options);
 }
@@ -705,7 +705,7 @@ TEST(DecimalConversion, CustomDecimalPoint) {
   options.decimal_point = '/';
 
   AssertConversion<Decimal128Type, Decimal128>(
-      decimal(14, 3), {"1/5,0/\n", ",-1e3\n"},
+      decimal128(14, 3), {"1/5,0/\n", ",-1e3\n"},
       {{Dec128("1.500"), Decimal128()}, {Decimal128(), Dec128("-1000.000")}},
       {{true, false}, {true, true}}, options);
   AssertConversionError(decimal128(14, 3), {"1.5\n"}, {0}, options);
@@ -713,16 +713,16 @@ TEST(DecimalConversion, CustomDecimalPoint) {
 
 TEST(DecimalConversion, Whitespace) {
   AssertConversion<Decimal128Type, Decimal128>(
-      decimal(5, 1), {" 12.00,34.5\n", " 0 ,-1e2 \n"},
+      decimal128(5, 1), {" 12.00,34.5\n", " 0 ,-1e2 \n"},
       {{Dec128("12.0"), Decimal128()}, {Dec128("34.5"), Dec128("-100.0")}});
 }
 
 TEST(DecimalConversion, OverflowFails) {
-  AssertConversionError(decimal(5, 0), {"1e6,0\n"}, {0});
+  AssertConversionError(decimal128(5, 0), {"1e6,0\n"}, {0});
 
-  AssertConversionError(decimal(5, 1), {"123.22\n"}, {0});
-  AssertConversionError(decimal(5, 1), {"12345.6\n"}, {0});
-  AssertConversionError(decimal(5, 1), {"1.61\n"}, {0});
+  AssertConversionError(decimal128(5, 1), {"123.22\n"}, {0});
+  AssertConversionError(decimal128(5, 1), {"12345.6\n"}, {0});
+  AssertConversionError(decimal128(5, 1), {"1.61\n"}, {0});
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -851,7 +851,7 @@ TEST(TestFixedSizeBinaryDictConverter, Errors) {
 }
 
 TEST(TestDecimalDictConverter, Basics) {
-  auto value_type = decimal(9, 3);
+  auto value_type = decimal128(9, 3);
 
   auto expected_dict = ArrayFromJSON(value_type, R"(["1.234", "456.789"])");
   auto expected_indices = ArrayFromJSON(int32(), "[0, 1, null, 1]");
@@ -861,7 +861,7 @@ TEST(TestDecimalDictConverter, Basics) {
 }
 
 TEST(TestDecimalDictConverter, CustomDecimalPoint) {
-  auto value_type = decimal(9, 3);
+  auto value_type = decimal128(9, 3);
 
   auto options = ConvertOptions::Defaults();
   options.decimal_point = '\'';
@@ -876,7 +876,7 @@ TEST(TestDecimalDictConverter, CustomDecimalPoint) {
 }
 
 TEST(TestDecimalDictConverter, Errors) {
-  auto value_type = decimal(9, 3);
+  auto value_type = decimal128(9, 3);
 
   // Overflow
   ASSERT_RAISES(Invalid, DictConversion(value_type, "1e10\n"));
diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc
index 56d7956076bf8..4cc93589cd892 100644
--- a/cpp/src/arrow/engine/substrait/expression_internal.cc
+++ b/cpp/src/arrow/engine/substrait/expression_internal.cc
@@ -951,15 +951,18 @@ struct ScalarToProtoImpl {
   Status Visit(const MonthIntervalScalar& s) { return NotImplemented(s); }
   Status Visit(const DayTimeIntervalScalar& s) { return NotImplemented(s); }
 
-  Status Visit(const Decimal128Scalar& s) {
+  template <typename T, typename TypeClass = typename T::TypeClass>
+  enable_if_decimal<TypeClass, Status> Visit(const T& s) {
+    using ValueType = typename T::ValueType;
+
     auto decimal = std::make_unique<Lit::Decimal>();
 
-    auto decimal_type = checked_cast<const Decimal128Type*>(s.type.get());
+    auto decimal_type = checked_cast<const TypeClass*>(s.type.get());
     decimal->set_precision(decimal_type->precision());
     decimal->set_scale(decimal_type->scale());
 
     decimal->set_value(reinterpret_cast<const char*>(s.value.native_endian_bytes()),
-                       sizeof(Decimal128));
+                       sizeof(ValueType));
 #if !ARROW_LITTLE_ENDIAN
     std::reverse(decimal->mutable_value()->begin(), decimal->mutable_value()->end());
 #endif
@@ -967,9 +970,6 @@ struct ScalarToProtoImpl {
     return Status::OK();
   }
 
-  // Need support for parameterized UDTs
-  Status Visit(const Decimal256Scalar& s) { return NotImplemented(s); }
-
   Status Visit(const BaseListScalar& s) {
     if (s.value->length() == 0) {
       ARROW_ASSIGN_OR_RAISE(auto list_type, ToProto(*s.type, /*nullable=*/true, ext_set_,
diff --git a/cpp/src/arrow/integration/json_internal.cc b/cpp/src/arrow/integration/json_internal.cc
index 89719b4ba4b2e..881efe2cc652a 100644
--- a/cpp/src/arrow/integration/json_internal.cc
+++ b/cpp/src/arrow/integration/json_internal.cc
@@ -314,14 +314,7 @@ class SchemaWriter {
     writer_->Int(type.list_size());
   }
 
-  void WriteTypeMetadata(const Decimal128Type& type) {
-    writer_->Key("precision");
-    writer_->Int(type.precision());
-    writer_->Key("scale");
-    writer_->Int(type.scale());
-  }
-
-  void WriteTypeMetadata(const Decimal256Type& type) {
+  void WriteTypeMetadata(const DecimalType& type) {
     writer_->Key("precision");
     writer_->Int(type.precision());
     writer_->Key("scale");
@@ -399,6 +392,8 @@ class SchemaWriter {
     return WritePrimitive("fixedsizebinary", type);
   }
 
+  Status Visit(const Decimal32Type& type) { return WritePrimitive("decimal32", type); }
+  Status Visit(const Decimal64Type& type) { return WritePrimitive("decimal64", type); }
   Status Visit(const Decimal128Type& type) { return WritePrimitive("decimal", type); }
   Status Visit(const Decimal256Type& type) { return WritePrimitive("decimal256", type); }
   Status Visit(const TimestampType& type) { return WritePrimitive("timestamp", type); }
@@ -595,6 +590,30 @@ class ArrayWriter {
     }
   }
 
+  void WriteDataValues(const Decimal32Array& arr) {
+    static const char null_string[] = "0";
+    for (int64_t i = 0; i < arr.length(); ++i) {
+      if (arr.IsValid(i)) {
+        const Decimal32 value(arr.GetValue(i));
+        writer_->String(value.ToIntegerString());
+      } else {
+        writer_->String(null_string, sizeof(null_string));
+      }
+    }
+  }
+
+  void WriteDataValues(const Decimal64Array& arr) {
+    static const char null_string[] = "0";
+    for (int64_t i = 0; i < arr.length(); ++i) {
+      if (arr.IsValid(i)) {
+        const Decimal64 value(arr.GetValue(i));
+        writer_->String(value.ToIntegerString());
+      } else {
+        writer_->String(null_string, sizeof(null_string));
+      }
+    }
+  }
+
   void WriteDataValues(const Decimal128Array& arr) {
     static const char null_string[] = "0";
     for (int64_t i = 0; i < arr.length(); ++i) {
@@ -969,12 +988,18 @@ Result<std::shared_ptr<DataType>> GetDecimal(const RjObject& json_type) {
     bit_width = maybe_bit_width.ValueOrDie();
   }
 
-  if (bit_width == 128) {
-    return decimal128(precision, scale);
-  } else if (bit_width == 256) {
-    return decimal256(precision, scale);
+  switch (bit_width) {
+    case 32:
+      return decimal32(precision, scale);
+    case 64:
+      return decimal64(precision, scale);
+    case 128:
+      return decimal128(precision, scale);
+    case 256:
+      return decimal256(precision, scale);
   }
-  return Status::Invalid("Only 128 bit and 256 Decimals are supported. Received",
+
+  return Status::Invalid("Only 32/64/128/256-bit Decimals are supported. Received ",
                          bit_width);
 }
 
diff --git a/cpp/src/arrow/ipc/json_simple.cc b/cpp/src/arrow/ipc/json_simple.cc
index 9fd449831c980..a55323f227cf8 100644
--- a/cpp/src/arrow/ipc/json_simple.cc
+++ b/cpp/src/arrow/ipc/json_simple.cc
@@ -386,6 +386,10 @@ class DecimalConverter final
   const DecimalSubtype* decimal_type_;
 };
 
+template <typename BuilderType = typename TypeTraits<Decimal32Type>::BuilderType>
+using Decimal32Converter = DecimalConverter<Decimal32Type, Decimal32, BuilderType>;
+template <typename BuilderType = typename TypeTraits<Decimal64Type>::BuilderType>
+using Decimal64Converter = DecimalConverter<Decimal64Type, Decimal64, BuilderType>;
 template <typename BuilderType = typename TypeTraits<Decimal128Type>::BuilderType>
 using Decimal128Converter = DecimalConverter<Decimal128Type, Decimal128, BuilderType>;
 template <typename BuilderType = typename TypeTraits<Decimal256Type>::BuilderType>
@@ -886,6 +890,8 @@ Status GetDictConverter(const std::shared_ptr<DataType>& type,
     PARAM_CONVERTER_CASE(Type::BINARY_VIEW, StringConverter, BinaryViewType)
     SIMPLE_CONVERTER_CASE(Type::FIXED_SIZE_BINARY, FixedSizeBinaryConverter,
                           FixedSizeBinaryType)
+    SIMPLE_CONVERTER_CASE(Type::DECIMAL32, Decimal32Converter, Decimal32Type)
+    SIMPLE_CONVERTER_CASE(Type::DECIMAL64, Decimal64Converter, Decimal64Type)
     SIMPLE_CONVERTER_CASE(Type::DECIMAL128, Decimal128Converter, Decimal128Type)
     SIMPLE_CONVERTER_CASE(Type::DECIMAL256, Decimal256Converter, Decimal256Type)
     default:
@@ -948,6 +954,8 @@ Status GetConverter(const std::shared_ptr<DataType>& type,
     SIMPLE_CONVERTER_CASE(Type::STRING_VIEW, StringConverter<StringViewType>)
     SIMPLE_CONVERTER_CASE(Type::BINARY_VIEW, StringConverter<BinaryViewType>)
     SIMPLE_CONVERTER_CASE(Type::FIXED_SIZE_BINARY, FixedSizeBinaryConverter<>)
+    SIMPLE_CONVERTER_CASE(Type::DECIMAL32, Decimal32Converter<>)
+    SIMPLE_CONVERTER_CASE(Type::DECIMAL64, Decimal64Converter<>)
     SIMPLE_CONVERTER_CASE(Type::DECIMAL128, Decimal128Converter<>)
     SIMPLE_CONVERTER_CASE(Type::DECIMAL256, Decimal256Converter<>)
     SIMPLE_CONVERTER_CASE(Type::SPARSE_UNION, UnionConverter)
diff --git a/cpp/src/arrow/ipc/json_simple_test.cc b/cpp/src/arrow/ipc/json_simple_test.cc
index d3201d8571b2c..7a45f0906639a 100644
--- a/cpp/src/arrow/ipc/json_simple_test.cc
+++ b/cpp/src/arrow/ipc/json_simple_test.cc
@@ -568,6 +568,14 @@ void TestDecimalBasic(std::shared_ptr<DataType> type) {
   AssertArraysEqual(*expected, *actual);
 }
 
+TEST(TestDecimal32, Basics) {
+  TestDecimalBasic<Decimal32, Decimal32Builder>(decimal32(8, 4));
+}
+
+TEST(TestDecimal64, Basics) {
+  TestDecimalBasic<Decimal64, Decimal64Builder>(decimal64(10, 4));
+}
+
 TEST(TestDecimal128, Basics) {
   TestDecimalBasic<Decimal128, Decimal128Builder>(decimal128(10, 4));
 }
@@ -577,7 +585,8 @@ TEST(TestDecimal256, Basics) {
 }
 
 TEST(TestDecimal, Errors) {
-  for (std::shared_ptr<DataType> type : {decimal128(10, 4), decimal256(10, 4)}) {
+  for (std::shared_ptr<DataType> type :
+       {decimal32(8, 4), decimal64(10, 4), decimal128(10, 4), decimal256(10, 4)}) {
     std::shared_ptr<Array> array;
 
     ASSERT_RAISES(Invalid, ArrayFromJSON(type, "[0]"));
@@ -589,7 +598,8 @@ TEST(TestDecimal, Errors) {
 }
 
 TEST(TestDecimal, Dictionary) {
-  for (std::shared_ptr<DataType> type : {decimal128(10, 2), decimal256(10, 2)}) {
+  for (std::shared_ptr<DataType> type :
+       {decimal32(8, 2), decimal64(10, 2), decimal128(10, 2), decimal256(10, 2)}) {
     AssertJSONDictArray(int32(), type,
                         R"(["123.45", "-78.90", "-78.90", null, "123.45"])",
                         /*indices=*/"[0, 1, 1, null, 0]",
diff --git a/cpp/src/arrow/ipc/metadata_internal.cc b/cpp/src/arrow/ipc/metadata_internal.cc
index be8d1ccc35f1a..3512fd1e6b928 100644
--- a/cpp/src/arrow/ipc/metadata_internal.cc
+++ b/cpp/src/arrow/ipc/metadata_internal.cc
@@ -278,13 +278,19 @@ Status ConcreteTypeFromFlatbuffer(flatbuf::Type type, const void* type_data,
       return Status::OK();
     case flatbuf::Type::Decimal: {
       auto dec_type = static_cast<const flatbuf::Decimal*>(type_data);
-      if (dec_type->bitWidth() == 128) {
-        return Decimal128Type::Make(dec_type->precision(), dec_type->scale()).Value(out);
-      } else if (dec_type->bitWidth() == 256) {
-        return Decimal256Type::Make(dec_type->precision(), dec_type->scale()).Value(out);
-      } else {
-        return Status::Invalid("Library only supports 128-bit or 256-bit decimal values");
+      switch (dec_type->bitWidth()) {
+        case 32:
+          return Decimal32Type::Make(dec_type->precision(), dec_type->scale()).Value(out);
+        case 64:
+          return Decimal64Type::Make(dec_type->precision(), dec_type->scale()).Value(out);
+        case 128:
+          return Decimal128Type::Make(dec_type->precision(), dec_type->scale())
+              .Value(out);
+        case 256:
+          return Decimal256Type::Make(dec_type->precision(), dec_type->scale())
+              .Value(out);
       }
+      return Status::Invalid("Library only supports 32/64/128/256-bit decimal values");
     }
     case flatbuf::Type::Date: {
       auto date_type = static_cast<const flatbuf::Date*>(type_data);
@@ -650,6 +656,24 @@ class FieldToFlatbufferVisitor {
     return Status::OK();
   }
 
+  Status Visit(const Decimal32Type& type) {
+    const auto& dec_type = checked_cast<const Decimal32Type&>(type);
+    fb_type_ = flatbuf::Type::Decimal;
+    type_offset_ = flatbuf::CreateDecimal(fbb_, dec_type.precision(), dec_type.scale(),
+                                          /*bitWidth=*/32)
+                       .Union();
+    return Status::OK();
+  }
+
+  Status Visit(const Decimal64Type& type) {
+    const auto& dec_type = checked_cast<const Decimal64Type&>(type);
+    fb_type_ = flatbuf::Type::Decimal;
+    type_offset_ = flatbuf::CreateDecimal(fbb_, dec_type.precision(), dec_type.scale(),
+                                          /*bitWidth=*/64)
+                       .Union();
+    return Status::OK();
+  }
+
   Status Visit(const Decimal128Type& type) {
     const auto& dec_type = checked_cast<const Decimal128Type&>(type);
     fb_type_ = flatbuf::Type::Decimal;
diff --git a/cpp/src/arrow/ipc/read_write_test.cc b/cpp/src/arrow/ipc/read_write_test.cc
index 39fd2c40fb4ec..6b4db71a844e4 100644
--- a/cpp/src/arrow/ipc/read_write_test.cc
+++ b/cpp/src/arrow/ipc/read_write_test.cc
@@ -336,7 +336,7 @@ TEST_F(TestSchemaMetadata, NestedDictionaryFields) {
     auto dict_type1 = dictionary(int8(), utf8(), /*ordered=*/true);
     auto dict_type2 = dictionary(int32(), fixed_size_binary(24));
     auto dict_type3 = dictionary(int32(), binary());
-    auto dict_type4 = dictionary(int8(), decimal(19, 7));
+    auto dict_type4 = dictionary(int8(), decimal128(19, 7));
 
     auto struct_type1 = struct_({field("s1", dict_type1), field("s2", dict_type2)});
     auto struct_type2 = struct_({field("s3", dict_type3), field("s4", dict_type4)});
diff --git a/cpp/src/arrow/json/converter.cc b/cpp/src/arrow/json/converter.cc
index c393b77acf334..6f775e24a229a 100644
--- a/cpp/src/arrow/json/converter.cc
+++ b/cpp/src/arrow/json/converter.cc
@@ -306,6 +306,8 @@ Status MakeConverter(const std::shared_ptr<DataType>& out_type, MemoryPool* pool
     CONVERTER_CASE(Type::LARGE_STRING, BinaryConverter<LargeStringType>);
     CONVERTER_CASE(Type::BINARY_VIEW, BinaryConverter<BinaryViewType>);
     CONVERTER_CASE(Type::STRING_VIEW, BinaryConverter<StringViewType>);
+    CONVERTER_CASE(Type::DECIMAL32, DecimalConverter<Decimal32Type>);
+    CONVERTER_CASE(Type::DECIMAL64, DecimalConverter<Decimal64Type>);
     CONVERTER_CASE(Type::DECIMAL128, DecimalConverter<Decimal128Type>);
     CONVERTER_CASE(Type::DECIMAL256, DecimalConverter<Decimal256Type>);
     default:
diff --git a/cpp/src/arrow/json/parser_test.cc b/cpp/src/arrow/json/parser_test.cc
index 681df4e6fa0ae..1b107aa020fd9 100644
--- a/cpp/src/arrow/json/parser_test.cc
+++ b/cpp/src/arrow/json/parser_test.cc
@@ -140,7 +140,7 @@ TEST(BlockParserWithSchema, SkipFieldsOutsideSchema) {
 TEST(BlockParserWithSchema, UnquotedDecimal) {
   auto options = ParseOptions::Defaults();
   options.explicit_schema =
-      schema({field("price", decimal(9, 2)), field("cost", decimal(9, 3))});
+      schema({field("price", decimal128(9, 2)), field("cost", decimal128(9, 3))});
   AssertParseColumns(options, unquoted_decimal_src(),
                      {field("price", utf8()), field("cost", utf8())},
                      {R"(["30.04", "1.23"])", R"(["30.001", "1.229"])"});
@@ -149,7 +149,7 @@ TEST(BlockParserWithSchema, UnquotedDecimal) {
 TEST(BlockParserWithSchema, MixedDecimal) {
   auto options = ParseOptions::Defaults();
   options.explicit_schema =
-      schema({field("price", decimal(9, 2)), field("cost", decimal(9, 3))});
+      schema({field("price", decimal128(9, 2)), field("cost", decimal128(9, 3))});
   AssertParseColumns(options, mixed_decimal_src(),
                      {field("price", utf8()), field("cost", utf8())},
                      {R"(["30.04", "1.23"])", R"(["30.001", "1.229"])"});
diff --git a/cpp/src/arrow/json/reader_test.cc b/cpp/src/arrow/json/reader_test.cc
index f941b51391bab..a52626413d68d 100644
--- a/cpp/src/arrow/json/reader_test.cc
+++ b/cpp/src/arrow/json/reader_test.cc
@@ -220,8 +220,8 @@ TEST_P(ReaderTest, MultipleChunks) {
 }
 
 TEST_P(ReaderTest, UnquotedDecimal) {
-  auto schema =
-      ::arrow::schema({field("price", decimal(9, 2)), field("cost", decimal(9, 3))});
+  auto schema = ::arrow::schema(
+      {field("price", decimal128(9, 2)), field("cost", decimal128(9, 3))});
   parse_options_.explicit_schema = schema;
   auto src = unquoted_decimal_src();
   SetUpReader(src);
@@ -235,8 +235,8 @@ TEST_P(ReaderTest, UnquotedDecimal) {
 }
 
 TEST_P(ReaderTest, MixedDecimal) {
-  auto schema =
-      ::arrow::schema({field("price", decimal(9, 2)), field("cost", decimal(9, 3))});
+  auto schema = ::arrow::schema(
+      {field("price", decimal128(9, 2)), field("cost", decimal128(9, 3))});
   parse_options_.explicit_schema = schema;
   auto src = mixed_decimal_src();
   SetUpReader(src);
diff --git a/cpp/src/arrow/pretty_print_test.cc b/cpp/src/arrow/pretty_print_test.cc
index 5d2256e8c5d44..108b212cca5b6 100644
--- a/cpp/src/arrow/pretty_print_test.cc
+++ b/cpp/src/arrow/pretty_print_test.cc
@@ -1106,10 +1106,11 @@ TEST_F(TestPrettyPrint, FixedSizeBinaryType) {
 }
 
 TEST_F(TestPrettyPrint, DecimalTypes) {
-  int32_t p = 19;
+  int32_t p = 9;
   int32_t s = 4;
 
-  for (auto type : {decimal128(p, s), decimal256(p, s)}) {
+  for (auto type :
+       {decimal32(p, s), decimal64(p, s), decimal128(p, s), decimal256(p, s)}) {
     auto array = ArrayFromJSON(type, "[\"123.4567\", \"456.7891\", null]");
 
     static const char* ex = "[\n  123.4567,\n  456.7891,\n  null\n]";
diff --git a/cpp/src/arrow/scalar.cc b/cpp/src/arrow/scalar.cc
index 252706fd0b387..85ceec9720214 100644
--- a/cpp/src/arrow/scalar.cc
+++ b/cpp/src/arrow/scalar.cc
@@ -84,6 +84,10 @@ struct ScalarHashImpl {
     return StdHash(s.value.days) & StdHash(s.value.months) & StdHash(s.value.nanoseconds);
   }
 
+  Status Visit(const Decimal32Scalar& s) { return StdHash(s.value.value()); }
+
+  Status Visit(const Decimal64Scalar& s) { return StdHash(s.value.value()); }
+
   Status Visit(const Decimal128Scalar& s) {
     return StdHash(s.value.low_bits()) & StdHash(s.value.high_bits());
   }
@@ -290,6 +294,24 @@ struct ScalarValidateImpl {
     return Status::OK();
   }
 
+  Status Visit(const Decimal32Scalar& s) {
+    const auto& ty = checked_cast<const DecimalType&>(*s.type);
+    if (!s.value.FitsInPrecision(ty.precision())) {
+      return Status::Invalid("Decimal value ", s.value.ToIntegerString(),
+                             " does not fit in precision of ", ty);
+    }
+    return Status::OK();
+  }
+
+  Status Visit(const Decimal64Scalar& s) {
+    const auto& ty = checked_cast<const DecimalType&>(*s.type);
+    if (!s.value.FitsInPrecision(ty.precision())) {
+      return Status::Invalid("Decimal value ", s.value.ToIntegerString(),
+                             " does not fit in precision of ", ty);
+    }
+    return Status::OK();
+  }
+
   Status Visit(const Decimal128Scalar& s) {
     const auto& ty = checked_cast<const DecimalType&>(*s.type);
     if (!s.value.FitsInPrecision(ty.precision())) {
diff --git a/cpp/src/arrow/scalar.h b/cpp/src/arrow/scalar.h
index 982a4c5113c92..7a273c46c1991 100644
--- a/cpp/src/arrow/scalar.h
+++ b/cpp/src/arrow/scalar.h
@@ -563,6 +563,14 @@ struct ARROW_EXPORT DecimalScalar : public internal::PrimitiveScalarBase {
   ValueType value;
 };
 
+struct ARROW_EXPORT Decimal32Scalar : public DecimalScalar<Decimal32Type, Decimal32> {
+  using DecimalScalar::DecimalScalar;
+};
+
+struct ARROW_EXPORT Decimal64Scalar : public DecimalScalar<Decimal64Type, Decimal64> {
+  using DecimalScalar::DecimalScalar;
+};
+
 struct ARROW_EXPORT Decimal128Scalar : public DecimalScalar<Decimal128Type, Decimal128> {
   using DecimalScalar::DecimalScalar;
 };
diff --git a/cpp/src/arrow/scalar_test.cc b/cpp/src/arrow/scalar_test.cc
index e9ec13e98b4ee..d19d7f8a39ec5 100644
--- a/cpp/src/arrow/scalar_test.cc
+++ b/cpp/src/arrow/scalar_test.cc
@@ -108,7 +108,7 @@ TEST(TestNullScalar, Cast) {
            list(int32()),
            struct_({field("f", int32())}),
            map(utf8(), int32()),
-           decimal(12, 2),
+           decimal128(12, 2),
            list_view(int32()),
            large_list(int32()),
            dense_union({field("string", utf8()), field("number", uint64())}),
diff --git a/cpp/src/arrow/testing/gtest_util.h b/cpp/src/arrow/testing/gtest_util.h
index 90311464c283b..89a986097f878 100644
--- a/cpp/src/arrow/testing/gtest_util.h
+++ b/cpp/src/arrow/testing/gtest_util.h
@@ -171,7 +171,10 @@ using PrimitiveArrowTypes =
 using TemporalArrowTypes =
     ::testing::Types<Date32Type, Date64Type, TimestampType, Time32Type, Time64Type>;
 
-using DecimalArrowTypes = ::testing::Types<Decimal128Type, Decimal256Type>;
+// we can uncomment Decimal32Type and Decimal64Type once the cast
+// functions are implemented for those types
+using DecimalArrowTypes =
+    ::testing::Types</*Decimal32Type, Decimal64Type,*/ Decimal128Type, Decimal256Type>;
 
 using BaseBinaryArrowTypes =
     ::testing::Types<BinaryType, LargeBinaryType, StringType, LargeStringType>;
diff --git a/cpp/src/arrow/testing/random.cc b/cpp/src/arrow/testing/random.cc
index 59de09fff83c5..b4b5bacc96356 100644
--- a/cpp/src/arrow/testing/random.cc
+++ b/cpp/src/arrow/testing/random.cc
@@ -286,13 +286,13 @@ struct DecimalGenerator {
 
   std::shared_ptr<Array> MakeRandomArray(int64_t size, double null_probability,
                                          int64_t alignment, MemoryPool* memory_pool) {
-    // 10**19 fits in a 64-bit unsigned integer
+    // 10**19 fits in a 64-bit signed integer
     static constexpr int32_t kMaxDigitsInInteger = 19;
     static constexpr int kNumIntegers = DecimalType::kByteWidth / 8;
 
     static_assert(
-        kNumIntegers ==
-            (DecimalType::kMaxPrecision + kMaxDigitsInInteger - 1) / kMaxDigitsInInteger,
+        kNumIntegers == (DecimalType::kMaxPrecision + kMaxDigitsInInteger - 1) /
+                            (kMaxDigitsInInteger + 1),
         "inconsistent decimal metadata: kMaxPrecision doesn't match kByteWidth");
 
     // First generate separate random values for individual components:
@@ -343,8 +343,60 @@ struct DecimalGenerator {
   }
 };
 
+template <typename DecimalType>
+struct SmallDecimalGenerator {
+  using DecimalBuilderType = typename TypeTraits<DecimalType>::BuilderType;
+  using DecimalValue = typename DecimalBuilderType::ValueType;
+  using IntegerType = typename DecimalValue::ValueType;
+  using IntArrowType = typename CTypeTraits<IntegerType>::ArrowType;
+
+  std::shared_ptr<DataType> type_;
+  RandomArrayGenerator* rng_;
+
+  static IntegerType MaxDecimalInteger(int32_t digits) {
+    return static_cast<IntegerType>(std::ceil(std::pow(10.0, digits))) - 1;
+  }
+
+  std::shared_ptr<Array> MakeRandomArray(int64_t size, double null_probability,
+                                         int64_t alignment, MemoryPool* memory_pool) {
+    static constexpr int32_t kMaxDigitsInInteger =
+        std::is_same_v<DecimalType, Decimal32Type> ? 9 : 18;
+    static_assert(
+        kMaxDigitsInInteger >= DecimalType::kByteWidth,
+        "inconsistent decimal metadata: kMaxPrecision doesn't match kByteWidth");
+
+    const auto& decimal_type = checked_cast<const DecimalType&>(*type_);
+
+    auto digits_to_generate = decimal_type.precision();
+    auto values = checked_pointer_cast<typename TypeTraits<IntArrowType>::ArrayType>(
+        rng_->Numeric<IntArrowType>(size, -1 * MaxDecimalInteger(digits_to_generate),
+                                    MaxDecimalInteger(digits_to_generate),
+                                    null_probability, alignment, memory_pool));
+
+    return values->View(type_).ValueOrDie();
+  }
+};
+
 }  // namespace
 
+std::shared_ptr<Array> RandomArrayGenerator::Decimal32(std::shared_ptr<DataType> type,
+                                                       int64_t size,
+                                                       double null_probability,
+                                                       int64_t alignment,
+                                                       MemoryPool* memory_pool) {
+  SmallDecimalGenerator<Decimal32Type> gen{type, this};
+  return gen.MakeRandomArray(size, null_probability, alignment, memory_pool);
+}
+
+std::shared_ptr<Array> RandomArrayGenerator::Decimal64(std::shared_ptr<DataType> type,
+                                                       int64_t size,
+                                                       double null_probability,
+                                                       int64_t alignment,
+                                                       MemoryPool* memory_pool) {
+  SmallDecimalGenerator<Decimal64Type> gen{type, this};
+  return gen.MakeRandomArray(size, null_probability, alignment, memory_pool);
+}
+
 std::shared_ptr<Array> RandomArrayGenerator::Decimal128(std::shared_ptr<DataType> type,
                                                         int64_t size,
                                                         double null_probability,
@@ -1075,6 +1127,12 @@ std::shared_ptr<Array> RandomArrayGenerator::ArrayOf(const Field& field, int64_t
           .ValueOrDie();
     }
 
+    case Type::type::DECIMAL32:
+      return Decimal32(field.type(), length, null_probability, alignment, memory_pool);
+
+    case Type::type::DECIMAL64:
+      return Decimal64(field.type(), length, null_probability, alignment, memory_pool);
+
     case Type::type::DECIMAL128:
       return Decimal128(field.type(), length, null_probability, alignment, memory_pool);
 
diff --git a/cpp/src/arrow/testing/random.h b/cpp/src/arrow/testing/random.h
index 9c0c5baae0f7c..ad87b12105916 100644
--- a/cpp/src/arrow/testing/random.h
+++ b/cpp/src/arrow/testing/random.h
@@ -297,6 +297,36 @@ class ARROW_TESTING_EXPORT RandomArrayGenerator {
     }
   }
 
+  /// \brief Generate a random Decimal32Array
+  ///
+  /// \param[in] type the type of the array to generate
+  ///            (must be an instance of Decimal32Type)
+  /// \param[in] size the size of the array to generate
+  /// \param[in] null_probability the probability of a value being null
+  /// \param[in] alignment alignment for memory allocations (in bytes)
+  /// \param[in] memory_pool memory pool to allocate memory from
+  ///
+  /// \return a generated Array
+  std::shared_ptr<Array> Decimal32(std::shared_ptr<DataType> type, int64_t size,
+                                   double null_probability = 0,
+                                   int64_t alignment = kDefaultBufferAlignment,
+                                   MemoryPool* memory_pool = default_memory_pool());
+
+  /// \brief Generate a random Decimal64Array
+  ///
+  /// \param[in] type the type of the array to generate
+  ///            (must be an instance of Decimal64Type)
+  /// \param[in] size the size of the array to generate
+  /// \param[in] null_probability the probability of a value being null
+  /// \param[in] alignment alignment for memory allocations (in bytes)
+  /// \param[in] memory_pool memory pool to allocate memory from
+  ///
+  /// \return a generated Array
+  std::shared_ptr<Array> Decimal64(std::shared_ptr<DataType> type, int64_t size,
+                                   double null_probability = 0,
+                                   int64_t alignment = kDefaultBufferAlignment,
+                                   MemoryPool* memory_pool = default_memory_pool());
+
   /// \brief Generate a random Decimal128Array
   ///
   /// \param[in] type the type of the array to generate
diff --git a/cpp/src/arrow/testing/random_test.cc b/cpp/src/arrow/testing/random_test.cc
index a92ecf4e9c45b..6f8621f8e9927 100644
--- a/cpp/src/arrow/testing/random_test.cc
+++ b/cpp/src/arrow/testing/random_test.cc
@@ -161,11 +161,12 @@ auto values = ::testing::Values(
     field("int64", int64()), field("float16", float16()), field("float32", float32()),
     field("float64", float64()), field("string", utf8()), field("binary", binary()),
     field("string_view", utf8_view()), field("binary_view", binary_view()),
-    field("fixed_size_binary", fixed_size_binary(8)),
-    field("decimal128", decimal128(8, 3)), field("decimal128", decimal128(29, -5)),
-    field("decimal256", decimal256(16, 4)), field("decimal256", decimal256(57, -6)),
-    field("date32", date32()), field("date64", date64()),
-    field("timestampns", timestamp(TimeUnit::NANO)),
+    field("fixed_size_binary", fixed_size_binary(8)), field("decimal32", decimal32(8, 3)),
+    field("decimal32", decimal32(9, -5)), field("decimal64", decimal64(16, 3)),
+    field("decimal64", decimal64(16, -5)), field("decimal128", decimal128(8, 3)),
+    field("decimal128", decimal128(29, -5)), field("decimal256", decimal256(16, 4)),
+    field("decimal256", decimal256(57, -6)), field("date32", date32()),
+    field("date64", date64()), field("timestampns", timestamp(TimeUnit::NANO)),
     field("timestamps", timestamp(TimeUnit::SECOND, "America/Phoenix")),
     field("time32ms", time32(TimeUnit::MILLI)), field("time64ns", time64(TimeUnit::NANO)),
     field("time32s", time32(TimeUnit::SECOND)),
@@ -313,14 +314,21 @@ class RandomDecimalArrayTest : public ::testing::Test {
   }
 };
 
-using DecimalTypes = ::testing::Types<Decimal128Type, Decimal256Type>;
+using DecimalTypes =
+    ::testing::Types<Decimal32Type, Decimal64Type, Decimal128Type, Decimal256Type>;
 TYPED_TEST_SUITE(RandomDecimalArrayTest, DecimalTypes);
 
 TYPED_TEST(RandomDecimalArrayTest, Basic) {
   random::RandomArrayGenerator rng(42);
 
+  using DecimalType = typename TestFixture::DecimalValue;
+
   for (const int32_t precision :
        {1, 2, 5, 9, 18, 19, 25, this->max_precision() - 1, this->max_precision()}) {
+    if (precision > DecimalType::kMaxPrecision) {
+      continue;
+    }
+
     ARROW_SCOPED_TRACE("precision = ", precision);
     const auto type = this->type(precision, 5);
     auto array = rng.ArrayOf(type, /*size=*/1000, /*null_probability=*/0.2);
diff --git a/cpp/src/arrow/type.cc b/cpp/src/arrow/type.cc
index ae9b213480f7b..2ebe57b2cc425 100644
--- a/cpp/src/arrow/type.cc
+++ b/cpp/src/arrow/type.cc
@@ -80,6 +80,10 @@ constexpr Type::type FixedSizeBinaryType::type_id;
 
 constexpr Type::type StructType::type_id;
 
+constexpr Type::type Decimal32Type::type_id;
+
+constexpr Type::type Decimal64Type::type_id;
+
 constexpr Type::type Decimal128Type::type_id;
 
 constexpr Type::type Decimal256Type::type_id;
@@ -122,6 +126,8 @@ std::vector<Type::type> AllTypeIds() {
           Type::HALF_FLOAT,
           Type::FLOAT,
           Type::DOUBLE,
+          Type::DECIMAL32,
+          Type::DECIMAL64,
           Type::DECIMAL128,
           Type::DECIMAL256,
           Type::DATE32,
@@ -192,6 +198,8 @@ std::string ToString(Type::type id) {
     TO_STRING_CASE(HALF_FLOAT)
     TO_STRING_CASE(FLOAT)
     TO_STRING_CASE(DOUBLE)
+    TO_STRING_CASE(DECIMAL32)
+    TO_STRING_CASE(DECIMAL64)
     TO_STRING_CASE(DECIMAL128)
     TO_STRING_CASE(DECIMAL256)
     TO_STRING_CASE(DATE32)
@@ -391,7 +399,7 @@ Result<std::shared_ptr<DataType>> WidenDecimals(
   const auto& right = checked_cast<const DecimalType&>(*other_type);
   if (!options.promote_numeric_width && left.bit_width() != right.bit_width()) {
     return Status::TypeError(
-        "Cannot promote decimal128 to decimal256 without promote_numeric_width=true");
+        "Cannot promote decimal types without promote_numeric_width=true");
   }
   const int32_t max_scale = std::max<int32_t>(left.scale(), right.scale());
   const int32_t common_precision =
@@ -400,8 +408,14 @@ Result<std::shared_ptr<DataType>> WidenDecimals(
   if (left.id() == Type::DECIMAL256 || right.id() == Type::DECIMAL256 ||
       common_precision > BasicDecimal128::kMaxPrecision) {
     return DecimalType::Make(Type::DECIMAL256, common_precision, max_scale);
+  } else if (left.id() == Type::DECIMAL128 || right.id() == Type::DECIMAL128 ||
+             common_precision > BasicDecimal64::kMaxPrecision) {
+    return DecimalType::Make(Type::DECIMAL128, common_precision, max_scale);
+  } else if (left.id() == Type::DECIMAL64 || right.id() == Type::DECIMAL64 ||
+             common_precision > BasicDecimal32::kMaxPrecision) {
+    return DecimalType::Make(Type::DECIMAL64, common_precision, max_scale);
   }
-  return DecimalType::Make(Type::DECIMAL128, common_precision, max_scale);
+  return DecimalType::Make(Type::DECIMAL32, common_precision, max_scale);
 }
 
 Result<std::shared_ptr<DataType>> MergeTypes(std::shared_ptr<DataType> promoted_type,
@@ -480,7 +494,7 @@ Result<std::shared_ptr<DataType>> MaybeMergeNumericTypes(
     ARROW_ASSIGN_OR_RAISE(const int32_t precision,
                           MaxDecimalDigitsForInteger(other_type->id()));
     ARROW_ASSIGN_OR_RAISE(const auto promoted_decimal,
-                          DecimalType::Make(promoted_type->id(), precision, 0));
+                          DecimalType::Make(promoted_type->id(), precision - 1, 0));
     ARROW_ASSIGN_OR_RAISE(promoted_type,
                           WidenDecimals(promoted_type, promoted_decimal, options));
     return promoted_type;
@@ -1428,12 +1442,17 @@ Result<std::shared_ptr<StructType>> StructType::SetField(
 
 Result<std::shared_ptr<DataType>> DecimalType::Make(Type::type type_id, int32_t precision,
                                                     int32_t scale) {
-  if (type_id == Type::DECIMAL128) {
-    return Decimal128Type::Make(precision, scale);
-  } else if (type_id == Type::DECIMAL256) {
-    return Decimal256Type::Make(precision, scale);
-  } else {
-    return Status::Invalid("Not a decimal type_id: ", type_id);
+  switch (type_id) {
+    case Type::DECIMAL32:
+      return Decimal32Type::Make(precision, scale);
+    case Type::DECIMAL64:
+      return Decimal64Type::Make(precision, scale);
+    case Type::DECIMAL128:
+      return Decimal128Type::Make(precision, scale);
+    case Type::DECIMAL256:
+      return Decimal256Type::Make(precision, scale);
+    default:
+      return Status::Invalid("Not a decimal type_id: ", type_id);
   }
 }
 
@@ -1459,20 +1478,51 @@ int32_t DecimalType::DecimalSize(int32_t precision) {
   return static_cast<int32_t>(std::ceil((precision / 8.0) * std::log2(10) + 1));
 }
 
+template <typename D>
+static Status ValidateDecimalPrecision(int32_t precision) {
+  if (precision < D::kMinPrecision || precision > D::kMaxPrecision) {
+    return Status::Invalid("Decimal precision out of range [", int32_t(D::kMinPrecision),
+                           ", ", int32_t(D::kMaxPrecision), "]: ", precision);
+  }
+  return Status::OK();
+}
+
+// ----------------------------------------------------------------------
+// Decimal32 type
+
+Decimal32Type::Decimal32Type(int32_t precision, int32_t scale)
+    : DecimalType(type_id, 4, precision, scale) {
+  ARROW_CHECK_OK(ValidateDecimalPrecision<Decimal32Type>(precision));
+}
+
+Result<std::shared_ptr<DataType>> Decimal32Type::Make(int32_t precision, int32_t scale) {
+  RETURN_NOT_OK(ValidateDecimalPrecision<Decimal32Type>(precision));
+  return std::make_shared<Decimal32Type>(precision, scale);
+}
+
+// ----------------------------------------------------------------------
+// Decimal64 type
+
+Decimal64Type::Decimal64Type(int32_t precision, int32_t scale)
+    : DecimalType(type_id, 8, precision, scale) {
+  ARROW_CHECK_OK(ValidateDecimalPrecision<Decimal64Type>(precision));
+}
+
+Result<std::shared_ptr<DataType>> Decimal64Type::Make(int32_t precision, int32_t scale) {
+  RETURN_NOT_OK(ValidateDecimalPrecision<Decimal64Type>(precision));
+  return std::make_shared<Decimal64Type>(precision, scale);
+}
+
 // ----------------------------------------------------------------------
 // Decimal128 type
 
 Decimal128Type::Decimal128Type(int32_t precision, int32_t scale)
     : DecimalType(type_id, 16, precision, scale) {
-  ARROW_CHECK_GE(precision, kMinPrecision);
-  ARROW_CHECK_LE(precision, kMaxPrecision);
+  ARROW_CHECK_OK(ValidateDecimalPrecision<Decimal128Type>(precision));
 }
 
 Result<std::shared_ptr<DataType>> Decimal128Type::Make(int32_t precision, int32_t scale) {
-  if (precision < kMinPrecision || precision > kMaxPrecision) {
-    return Status::Invalid("Decimal precision out of range [", int32_t(kMinPrecision),
-                           ", ", int32_t(kMaxPrecision), "]: ", precision);
-  }
+  RETURN_NOT_OK(ValidateDecimalPrecision<Decimal128Type>(precision));
   return std::make_shared<Decimal128Type>(precision, scale);
 }
 
@@ -1481,15 +1531,11 @@ Result<std::shared_ptr<DataType>> Decimal128Type::Make(int32_t precision, int32_
 
 Decimal256Type::Decimal256Type(int32_t precision, int32_t scale)
     : DecimalType(type_id, 32, precision, scale) {
-  ARROW_CHECK_GE(precision, kMinPrecision);
-  ARROW_CHECK_LE(precision, kMaxPrecision);
+  ARROW_CHECK_OK(ValidateDecimalPrecision<Decimal256Type>(precision));
 }
 
 Result<std::shared_ptr<DataType>> Decimal256Type::Make(int32_t precision, int32_t scale) {
-  if (precision < kMinPrecision || precision > kMaxPrecision) {
-    return Status::Invalid("Decimal precision out of range [", int32_t(kMinPrecision),
-                           ", ", int32_t(kMaxPrecision), "]: ", precision);
-  }
+  RETURN_NOT_OK(ValidateDecimalPrecision<Decimal256Type>(precision));
   return std::make_shared<Decimal256Type>(precision, scale);
 }
 
@@ -3305,6 +3351,21 @@ std::shared_ptr<DataType> decimal(int32_t precision, int32_t scale) {
                                                     : decimal256(precision, scale);
 }
 
+std::shared_ptr<DataType> smallest_decimal(int32_t precision, int32_t scale) {
+  return precision <= Decimal32Type::kMaxPrecision    ? decimal32(precision, scale)
+         : precision <= Decimal64Type::kMaxPrecision  ? decimal64(precision, scale)
+         : precision <= Decimal128Type::kMaxPrecision ? decimal128(precision, scale)
+                                                      : decimal256(precision, scale);
+}
+
+std::shared_ptr<DataType> decimal32(int32_t precision, int32_t scale) {
+  return std::make_shared<Decimal32Type>(precision, scale);
+}
+
+std::shared_ptr<DataType> decimal64(int32_t precision, int32_t scale) {
+  return std::make_shared<Decimal64Type>(precision, scale);
+}
+
 std::shared_ptr<DataType> decimal128(int32_t precision, int32_t scale) {
   return std::make_shared<Decimal128Type>(precision, scale);
 }
@@ -3313,6 +3374,18 @@ std::shared_ptr<DataType> decimal256(int32_t precision, int32_t scale) {
   return std::make_shared<Decimal256Type>(precision, scale);
 }
 
+std::string Decimal32Type::ToString(bool show_metadata) const {
+  std::stringstream s;
+  s << "decimal32(" << precision_ << ", " << scale_ << ")";
+  return s.str();
+}
+
+std::string Decimal64Type::ToString(bool show_metadata) const {
+  std::stringstream s;
+  s << "decimal64(" << precision_ << ", " << scale_ << ")";
+  return s.str();
+}
+
 std::string Decimal128Type::ToString(bool show_metadata) const {
   std::stringstream s;
   s << "decimal128(" << precision_ << ", " << scale_ << ")";
diff --git a/cpp/src/arrow/type.h b/cpp/src/arrow/type.h
index e0f87e6a9d263..3d7786bd37e09 100644
--- a/cpp/src/arrow/type.h
+++ b/cpp/src/arrow/type.h
@@ -1024,6 +1024,76 @@ class ARROW_EXPORT DecimalType : public FixedSizeBinaryType {
   int32_t scale_;
 };
 
+/// \brief Concrete type class for 32-bit decimal data
+///
+/// Arrow decimals are fixed-point decimal numbers encoded as a scaled
+/// integer.  The precision is the number of significant digits that the
+/// decimal type can represent; the scale is the number of digits after
+/// the decimal point (note the scale can be negative).
+///
+/// As an example, `Decimal32Type(7, 3)` can exactly represent the numbers
+/// 1234.567 and -1234.567 (encoded internally as the 32-bit integers
+/// 1234567 and -1234567, respectively), but neither 12345.67 nor 123.4567.
+///
+/// Decimal32Type has a maximum precision of 9 significant digits
+/// (also available as Decimal32Type::kMaxPrecision).
+/// If higher precision is needed, consider using Decimal64Type,
+/// Decimal128Type or Decimal256Type.
+class ARROW_EXPORT Decimal32Type : public DecimalType {
+ public:
+  static constexpr Type::type type_id = Type::DECIMAL32;
+
+  static constexpr const char* type_name() { return "decimal32"; }
+
+  /// Decimal32Type constructor that aborts on invalid input.
+  explicit Decimal32Type(int32_t precision, int32_t scale);
+
+  /// Decimal32Type constructor that returns an error on invalid input
+  static Result<std::shared_ptr<DataType>> Make(int32_t precision, int32_t scale);
+
+  std::string ToString(bool show_metadata = false) const override;
+  std::string name() const override { return "decimal32"; }
+
+  static constexpr int32_t kMinPrecision = 1;
+  static constexpr int32_t kMaxPrecision = 9;
+  static constexpr int32_t kByteWidth = 4;
+};
+
+/// \brief Concrete type class for 64-bit decimal data
+///
+/// Arrow decimals are fixed-point decimal numbers encoded as a scaled
+/// integer.  The precision is the number of significant digits that the
+/// decimal type can represent; the scale is the number of digits after
+/// the decimal point (note the scale can be negative).
+///
+/// As an example, `Decimal64Type(7, 3)` can exactly represent the numbers
+/// 1234.567 and -1234.567 (encoded internally as the 64-bit integers
+/// 1234567 and -1234567, respectively), but neither 12345.67 nor 123.4567.
+///
+/// Decimal64Type has a maximum precision of 18 significant digits
+/// (also available as Decimal64Type::kMaxPrecision).
+/// If higher precision is needed, consider using Decimal128Type or
+/// Decimal256Type.
+class ARROW_EXPORT Decimal64Type : public DecimalType {
+ public:
+  static constexpr Type::type type_id = Type::DECIMAL64;
+
+  static constexpr const char* type_name() { return "decimal64"; }
+
+  /// Decimal32Type constructor that aborts on invalid input.
+  explicit Decimal64Type(int32_t precision, int32_t scale);
+
+  /// Decimal32Type constructor that returns an error on invalid input
+  static Result<std::shared_ptr<DataType>> Make(int32_t precision, int32_t scale);
+
+  std::string ToString(bool show_metadata = false) const override;
+  std::string name() const override { return "decimal64"; }
+
+  static constexpr int32_t kMinPrecision = 1;
+  static constexpr int32_t kMaxPrecision = 18;
+  static constexpr int32_t kByteWidth = 8;
+};
+
 /// \brief Concrete type class for 128-bit decimal data
 ///
 /// Arrow decimals are fixed-point decimal numbers encoded as a scaled
diff --git a/cpp/src/arrow/type_benchmark.cc b/cpp/src/arrow/type_benchmark.cc
index 0d1425a405709..f502c4b7c8604 100644
--- a/cpp/src/arrow/type_benchmark.cc
+++ b/cpp/src/arrow/type_benchmark.cc
@@ -105,8 +105,8 @@ static std::vector<std::shared_ptr<Schema>> SampleSchemas() {
   auto fb2 = field("bs", utf8());
   auto fc1 = field("cs", list(fixed_size_binary(10)));
   auto fc2 = field("cs", list(fixed_size_binary(10)));
-  auto fd1 = field("ds", decimal(19, 5));
-  auto fd2 = field("ds", decimal(19, 5));
+  auto fd1 = field("ds", decimal128(19, 5));
+  auto fd2 = field("ds", decimal128(19, 5));
   auto fe1 = field("es", map(utf8(), int32()));
   auto fe2 = field("es", map(utf8(), int32()));
   auto ff1 = field("fs", dictionary(int8(), binary()));
diff --git a/cpp/src/arrow/type_fwd.h b/cpp/src/arrow/type_fwd.h
index 8faebe217f141..69029b67ab7db 100644
--- a/cpp/src/arrow/type_fwd.h
+++ b/cpp/src/arrow/type_fwd.h
@@ -175,15 +175,25 @@ class StructArray;
 class StructBuilder;
 struct StructScalar;
 
+class Decimal32;
+class Decimal64;
 class Decimal128;
 class Decimal256;
 class DecimalType;
+class Decimal32Type;
+class Decimal64Type;
 class Decimal128Type;
 class Decimal256Type;
+class Decimal32Array;
+class Decimal64Array;
 class Decimal128Array;
 class Decimal256Array;
+class Decimal32Builder;
+class Decimal64Builder;
 class Decimal128Builder;
 class Decimal256Builder;
+struct Decimal32Scalar;
+struct Decimal64Scalar;
 struct Decimal128Scalar;
 struct Decimal256Scalar;
 
@@ -448,6 +458,12 @@ struct Type {
     /// Like LIST_VIEW, but with 64-bit offsets and sizes
     LARGE_LIST_VIEW = 42,
 
+    /// Precision- and scale-based decimal type with 32 bits.
+    DECIMAL32 = 43,
+
+    /// Precision- and scale-based decimal type with 64 bits.
+    DECIMAL64 = 44,
+
     // Leave this at the end
     MAX_ID
   };
@@ -512,9 +528,29 @@ std::shared_ptr<DataType> fixed_size_binary(int32_t byte_width);
 ///
 /// If the precision is greater than 38, a Decimal256Type is returned,
 /// otherwise a Decimal128Type.
+///
+/// Deprecated: prefer `smallest_decimal` instead.
+ARROW_DEPRECATED("Deprecated in 18.0. Use `smallest_decimal` instead")
 ARROW_EXPORT
 std::shared_ptr<DataType> decimal(int32_t precision, int32_t scale);
 
+/// \brief Create a the smallest DecimalType instance depending on precision
+///
+/// Given the requested precision and scale, the smallest DecimalType which
+/// is able to represent that precision will be returned. As different
+/// bit-widths for decimal types are added, the concrete data type returned
+/// here can potentially change accordingly.
+ARROW_EXPORT
+std::shared_ptr<DataType> smallest_decimal(int32_t precision, int32_t scale);
+
+/// \brief Create a Decimal32Type instance
+ARROW_EXPORT
+std::shared_ptr<DataType> decimal32(int32_t precision, int32_t scale);
+
+/// \brief Create a Decimal64Type instance
+ARROW_EXPORT
+std::shared_ptr<DataType> decimal64(int32_t precision, int32_t scale);
+
 /// \brief Create a Decimal128Type instance
 ARROW_EXPORT
 std::shared_ptr<DataType> decimal128(int32_t precision, int32_t scale);
diff --git a/cpp/src/arrow/type_test.cc b/cpp/src/arrow/type_test.cc
index f641bb9fab738..7610be8a47f4e 100644
--- a/cpp/src/arrow/type_test.cc
+++ b/cpp/src/arrow/type_test.cc
@@ -1219,12 +1219,16 @@ TEST_F(TestUnifySchemas, Decimal) {
   auto options = Field::MergeOptions::Defaults();
 
   options.promote_decimal_to_float = true;
+  CheckPromoteTo(decimal32(3, 2), {float32(), float64()}, options);
+  CheckPromoteTo(decimal64(3, 2), {float32(), float64()}, options);
   CheckPromoteTo(decimal128(3, 2), {float32(), float64()}, options);
   CheckPromoteTo(decimal256(3, 2), {float32(), float64()}, options);
 
   options.promote_integer_to_decimal = true;
-  CheckPromoteTo(int32(), decimal128(3, 2), decimal128(12, 2), options);
-  CheckPromoteTo(int32(), decimal128(3, -2), decimal128(10, 0), options);
+  CheckPromoteTo(int32(), decimal32(3, 2), decimal64(11, 2), options);
+  CheckPromoteTo(int32(), decimal64(3, -2), decimal64(9, 0), options);
+  CheckPromoteTo(int32(), decimal128(3, 2), decimal128(11, 2), options);
+  CheckPromoteTo(int32(), decimal128(3, -2), decimal128(9, 0), options);
 
   options.promote_decimal = true;
   CheckPromoteTo(decimal128(3, 2), decimal128(5, 2), decimal128(5, 2), options);
@@ -1241,15 +1245,15 @@ TEST_F(TestUnifySchemas, Decimal) {
   CheckPromoteTo(decimal256(3, -2), decimal256(5, -2), decimal256(5, -2), options);
 
   // int32() is essentially decimal128(10, 0)
-  CheckPromoteTo(int32(), decimal128(3, 2), decimal128(12, 2), options);
-  CheckPromoteTo(int32(), decimal128(3, -2), decimal128(10, 0), options);
-  CheckPromoteTo(int64(), decimal128(38, 37), decimal256(56, 37), options);
+  CheckPromoteTo(int32(), decimal128(3, 2), decimal128(11, 2), options);
+  CheckPromoteTo(int32(), decimal128(3, -2), decimal128(9, 0), options);
+  CheckPromoteTo(int64(), decimal128(38, 37), decimal256(55, 37), options);
 
   CheckUnifyFailsTypeError(decimal256(1, 0), decimal128(1, 0), options);
 
   options.promote_numeric_width = true;
   CheckPromoteTo(decimal128(3, 2), decimal256(5, 2), decimal256(5, 2), options);
-  CheckPromoteTo(int32(), decimal128(38, 37), decimal256(47, 37), options);
+  CheckPromoteTo(int32(), decimal128(38, 37), decimal256(46, 37), options);
   CheckUnifyFailsInvalid(decimal128(38, 10), decimal256(76, 5), options);
 
   CheckUnifyFailsInvalid(int64(), decimal256(76, 75), options);
@@ -2219,6 +2223,50 @@ TEST(TestDictionaryType, Equals) {
   AssertTypeNotEqual(*t5, *t6);
 }
 
+TEST(TypesTest, SmallestDecimal) {
+  for (int32_t i = 1; i < 76; ++i) {
+    auto t = smallest_decimal(i, 4);
+
+    if (i <= 9) {
+      EXPECT_EQ(t->id(), Type::DECIMAL32);
+    } else if (i <= 18) {
+      EXPECT_EQ(t->id(), Type::DECIMAL64);
+    } else if (i <= 38) {
+      EXPECT_EQ(t->id(), Type::DECIMAL128);
+    } else {
+      EXPECT_EQ(t->id(), Type::DECIMAL256);
+    }
+  }
+}
+
+TEST(TypesTest, TestDecimal32) {
+  Decimal32Type t1(4, 4);
+
+  EXPECT_EQ(t1.id(), Type::DECIMAL32);
+  EXPECT_EQ(t1.precision(), 4);
+  EXPECT_EQ(t1.scale(), 4);
+
+  EXPECT_EQ(t1.ToString(), std::string("decimal32(4, 4)"));
+
+  // Test properties
+  EXPECT_EQ(t1.byte_width(), 4);
+  EXPECT_EQ(t1.bit_width(), 32);
+}
+
+TEST(TypesTest, TestDecimal64) {
+  Decimal64Type t1(12, 4);
+
+  EXPECT_EQ(t1.id(), Type::DECIMAL64);
+  EXPECT_EQ(t1.precision(), 12);
+  EXPECT_EQ(t1.scale(), 4);
+
+  EXPECT_EQ(t1.ToString(), std::string("decimal64(12, 4)"));
+
+  // Test properties
+  EXPECT_EQ(t1.byte_width(), 8);
+  EXPECT_EQ(t1.bit_width(), 64);
+}
+
 TEST(TypesTest, TestDecimal128Small) {
   Decimal128Type t1(8, 4);
 
diff --git a/cpp/src/arrow/type_traits.cc b/cpp/src/arrow/type_traits.cc
index ded54aff463c1..780bef1239845 100644
--- a/cpp/src/arrow/type_traits.cc
+++ b/cpp/src/arrow/type_traits.cc
@@ -72,14 +72,18 @@ int RequiredValueAlignmentForBuffer(Type::type type_id, int buffer_index) {
     case Type::MAP:                // Same as LIST
     case Type::INTERVAL_MONTHS:    // Stored as int32_t*
     case Type::INTERVAL_DAY_TIME:  // Stored as two contiguous 32-bit integers
+    case Type::DECIMAL32:  // May be cast to SmallBasicDecimal* which requires alignment
+                           // of 4
       return 4;
     case Type::INT64:
     case Type::UINT64:
     case Type::DOUBLE:
-    case Type::DECIMAL128:       // May be cast to GenericBasicDecimal* which requires
-                                 // alignment of 8
-    case Type::DECIMAL256:       // May be cast to GenericBasicDecimal* which requires
-                                 // alignment of 8
+    case Type::DECIMAL64:   // May be cast to SmallBasicDecimal* which requires alignment
+                            // of 8
+    case Type::DECIMAL128:  // May be cast to GenericBasicDecimal* which requires
+                            // alignment of 8
+    case Type::DECIMAL256:  // May be cast to GenericBasicDecimal* which requires
+                            // alignment of 8
     case Type::LARGE_BINARY:     // Offsets may be cast to int64_t*
     case Type::LARGE_STRING:     // Offsets may be cast to int64_t*
     case Type::LARGE_LIST:       // Offsets may be cast to int64_t*
diff --git a/cpp/src/arrow/type_traits.h b/cpp/src/arrow/type_traits.h
index 96b6ccd26a79e..6da05bd8f1435 100644
--- a/cpp/src/arrow/type_traits.h
+++ b/cpp/src/arrow/type_traits.h
@@ -67,6 +67,8 @@ TYPE_ID_TRAIT(INTERVAL_DAY_TIME, DayTimeIntervalType)
 TYPE_ID_TRAIT(INTERVAL_MONTH_DAY_NANO, MonthDayNanoIntervalType)
 TYPE_ID_TRAIT(INTERVAL_MONTHS, MonthIntervalType)
 TYPE_ID_TRAIT(DURATION, DurationType)
+TYPE_ID_TRAIT(DECIMAL32, Decimal32Type)
+TYPE_ID_TRAIT(DECIMAL64, Decimal64Type)
 TYPE_ID_TRAIT(DECIMAL128, Decimal128Type)
 TYPE_ID_TRAIT(DECIMAL256, Decimal256Type)
 TYPE_ID_TRAIT(STRUCT, StructType)
@@ -314,6 +316,24 @@ struct TypeTraits<HalfFloatType> {
   static inline std::shared_ptr<DataType> type_singleton() { return float16(); }
 };
 
+template <>
+struct TypeTraits<Decimal32Type> {
+  using ArrayType = Decimal32Array;
+  using BuilderType = Decimal32Builder;
+  using ScalarType = Decimal32Scalar;
+  using CType = Decimal32;
+  constexpr static bool is_parameter_free = false;
+};
+
+template <>
+struct TypeTraits<Decimal64Type> {
+  using ArrayType = Decimal64Array;
+  using BuilderType = Decimal64Builder;
+  using ScalarType = Decimal64Scalar;
+  using CType = Decimal64;
+  constexpr static bool is_parameter_free = false;
+};
+
 template <>
 struct TypeTraits<Decimal128Type> {
   using ArrayType = Decimal128Array;
@@ -723,6 +743,18 @@ using is_decimal_type = std::is_base_of<DecimalType, T>;
 template <typename T, typename R = void>
 using enable_if_decimal = enable_if_t<is_decimal_type<T>::value, R>;
 
+template <typename T>
+using is_decimal32_type = std::is_base_of<Decimal32Type, T>;
+
+template <typename T, typename R = void>
+using enable_if_decimal32 = enable_if_t<is_decimal32_type<T>::value, R>;
+
+template <typename T>
+using is_decimal64_type = std::is_base_of<Decimal64Type, T>;
+
+template <typename T, typename R = void>
+using enable_if_decimal64 = enable_if_t<is_decimal64_type<T>::value, R>;
+
 template <typename T>
 using is_decimal128_type = std::is_base_of<Decimal128Type, T>;
 
@@ -1059,6 +1091,8 @@ constexpr bool is_numeric(Type::type type_id) {
 /// \return whether type-id is a decimal type one
 constexpr bool is_decimal(Type::type type_id) {
   switch (type_id) {
+    case Type::DECIMAL32:
+    case Type::DECIMAL64:
     case Type::DECIMAL128:
     case Type::DECIMAL256:
       return true;
@@ -1293,6 +1327,8 @@ constexpr bool is_dictionary(Type::type type_id) { return type_id == Type::DICTI
 /// \return whether type-id is a fixed-size-binary type one
 constexpr bool is_fixed_size_binary(Type::type type_id) {
   switch (type_id) {
+    case Type::DECIMAL32:
+    case Type::DECIMAL64:
     case Type::DECIMAL128:
     case Type::DECIMAL256:
     case Type::FIXED_SIZE_BINARY:
@@ -1475,6 +1511,10 @@ static inline int bit_width(Type::type type_id) {
     case Type::INTERVAL_MONTH_DAY_NANO:
       return 128;
 
+    case Type::DECIMAL32:
+      return 32;
+    case Type::DECIMAL64:
+      return 64;
     case Type::DECIMAL128:
       return 128;
     case Type::DECIMAL256:
diff --git a/cpp/src/arrow/util/align_util_test.cc b/cpp/src/arrow/util/align_util_test.cc
index c116898114e03..457cbbd30f4fc 100644
--- a/cpp/src/arrow/util/align_util_test.cc
+++ b/cpp/src/arrow/util/align_util_test.cc
@@ -344,9 +344,10 @@ TEST(EnsureAlignment, Table) {
 using TypesRequiringSomeKindOfAlignment =
     testing::Types<Int16Type, Int32Type, Int64Type, UInt16Type, UInt32Type, UInt64Type,
                    FloatType, DoubleType, Date32Type, Date64Type, Time32Type, Time64Type,
-                   Decimal128Type, Decimal256Type, TimestampType, DurationType, MapType,
-                   DenseUnionType, LargeBinaryType, LargeListType, LargeStringType,
-                   MonthIntervalType, DayTimeIntervalType, MonthDayNanoIntervalType>;
+                   Decimal32Type, Decimal64Type, Decimal128Type, Decimal256Type,
+                   TimestampType, DurationType, MapType, DenseUnionType, LargeBinaryType,
+                   LargeListType, LargeStringType, MonthIntervalType, DayTimeIntervalType,
+                   MonthDayNanoIntervalType>;
 
 using TypesNotRequiringAlignment =
     testing::Types<NullType, Int8Type, UInt8Type, FixedSizeListType, FixedSizeBinaryType,
@@ -367,6 +368,16 @@ std::shared_ptr<DataType> sample_type<FixedSizeListType>() {
   return fixed_size_list(uint8(), 16);
 }
 
+template <>
+std::shared_ptr<DataType> sample_type<Decimal32Type>() {
+  return decimal32(8, 6);
+}
+
+template <>
+std::shared_ptr<DataType> sample_type<Decimal64Type>() {
+  return decimal64(16, 6);
+}
+
 template <>
 std::shared_ptr<DataType> sample_type<Decimal128Type>() {
   return decimal128(32, 6);
diff --git a/cpp/src/arrow/util/basic_decimal.cc b/cpp/src/arrow/util/basic_decimal.cc
index 0835ab9074a48..22db1e7051903 100644
--- a/cpp/src/arrow/util/basic_decimal.cc
+++ b/cpp/src/arrow/util/basic_decimal.cc
@@ -50,6 +50,331 @@ static constexpr uint64_t kInt64Mask = 0xFFFFFFFFFFFFFFFF;
 static constexpr uint64_t kInt32Mask = 0xFFFFFFFF;
 #endif
 
+DecimalStatus BasicDecimal32::Divide(const BasicDecimal32& divisor,
+                                     BasicDecimal32* result,
+                                     BasicDecimal32* remainder) const {
+  if (divisor.value_ == 0) {
+    return DecimalStatus::kDivideByZero;
+  }
+
+  *result = value_ / divisor.value_;
+  if (remainder) {
+    *remainder = value_ % divisor.value_;
+  }
+  return DecimalStatus::kSuccess;
+}
+
+BasicDecimal32& BasicDecimal32::operator<<=(uint32_t bits) {
+  if (bits != 0) {
+    if (bits < 32) {
+      value_ = SafeLeftShift(value_, bits);
+    } else {
+      value_ = 0;
+    }
+  }
+  return *this;
+}
+
+BasicDecimal32& BasicDecimal32::operator>>=(uint32_t bits) {
+  if (bits != 0) {
+    if (bits < 32) {
+      value_ >>= bits;
+    } else {
+      value_ = 0;
+    }
+  }
+  return *this;
+}
+
+void BasicDecimal32::GetWholeAndFraction(int scale, BasicDecimal32* whole,
+                                         BasicDecimal32* fraction) const {
+  DCHECK_GE(scale, 0);
+  DCHECK_LE(scale, kMaxScale);
+
+  BasicDecimal32 multiplier(DecimalTraits<BasicDecimal32>::powers_of_ten()[scale]);
+  auto s = Divide(multiplier, whole, fraction);
+  DCHECK_EQ(s, DecimalStatus::kSuccess);
+}
+
+const BasicDecimal32& BasicDecimal32::GetMaxValue() {
+  return DecimalTraits<BasicDecimal32>::kMaxValue;
+}
+
+BasicDecimal32 BasicDecimal32::GetMaxValue(int32_t precision) {
+  DCHECK_GE(precision, 0);
+  DCHECK_LE(precision, kMaxPrecision);
+  return DecimalTraits<BasicDecimal32>::powers_of_ten()[precision];
+}
+
+BasicDecimal32 BasicDecimal32::IncreaseScaleBy(int32_t increase_by) const {
+  DCHECK_GE(increase_by, 0);
+  DCHECK_LE(increase_by, kMaxScale);
+  return (*this) * DecimalTraits<BasicDecimal32>::powers_of_ten()[increase_by];
+}
+
+BasicDecimal32 BasicDecimal32::ReduceScaleBy(int32_t reduce_by, bool round) const {
+  DCHECK_GE(reduce_by, 0);
+  DCHECK_LE(reduce_by, kMaxScale);
+
+  if (reduce_by == 0) {
+    return *this;
+  }
+
+  BasicDecimal32 divisor(DecimalTraits<BasicDecimal32>::powers_of_ten()[reduce_by]);
+  BasicDecimal32 result;
+  BasicDecimal32 remainder;
+  auto s = Divide(divisor, &result, &remainder);
+  DCHECK_EQ(s, DecimalStatus::kSuccess);
+  if (round) {
+    auto divisor_half = DecimalTraits<BasicDecimal32>::half_powers_of_ten()[reduce_by];
+    if (remainder.Abs() >= divisor_half) {
+      result += Sign();
+    }
+  }
+  return result;
+}
+
+const BasicDecimal32& BasicDecimal32::GetScaleMultiplier(int32_t scale) {
+  DCHECK_GE(scale, 0);
+  DCHECK_LE(scale, kMaxScale);
+
+  return DecimalTraits<BasicDecimal32>::powers_of_ten()[scale];
+}
+
+const BasicDecimal32& BasicDecimal32::GetHalfScaleMultiplier(int32_t scale) {
+  DCHECK_GE(scale, 0);
+  DCHECK_LE(scale, kMaxScale);
+
+  return DecimalTraits<BasicDecimal32>::half_powers_of_ten()[scale];
+}
+
+BasicDecimal32::operator BasicDecimal64() const {
+  return BasicDecimal64(static_cast<int64_t>(value()));
+}
+
+DecimalStatus BasicDecimal64::Divide(const BasicDecimal64& divisor,
+                                     BasicDecimal64* result,
+                                     BasicDecimal64* remainder) const {
+  if (divisor.value_ == 0) {
+    return DecimalStatus::kDivideByZero;
+  }
+
+  *result = value_ / divisor.value_;
+  if (remainder) {
+    *remainder = value_ % divisor.value_;
+  }
+  return DecimalStatus::kSuccess;
+}
+
+BasicDecimal64& BasicDecimal64::operator<<=(uint32_t bits) {
+  if (bits != 0) {
+    if (bits < 64) {
+      value_ = SafeLeftShift(value_, bits);
+    } else {
+      value_ = 0;
+    }
+  }
+  return *this;
+}
+
+BasicDecimal64& BasicDecimal64::operator>>=(uint32_t bits) {
+  if (bits != 0) {
+    if (bits < 64) {
+      value_ >>= bits;
+    } else {
+      value_ = 0;
+    }
+  }
+  return *this;
+}
+
+void BasicDecimal64::GetWholeAndFraction(int scale, BasicDecimal64* whole,
+                                         BasicDecimal64* fraction) const {
+  DCHECK_GE(scale, 0);
+  DCHECK_LE(scale, kMaxScale);
+
+  BasicDecimal64 multiplier(DecimalTraits<BasicDecimal64>::powers_of_ten()[scale]);
+  auto s = Divide(multiplier, whole, fraction);
+  DCHECK_EQ(s, DecimalStatus::kSuccess);
+}
+
+const BasicDecimal64& BasicDecimal64::GetMaxValue() {
+  return DecimalTraits<BasicDecimal64>::kMaxValue;
+}
+
+BasicDecimal64 BasicDecimal64::GetMaxValue(int32_t precision) {
+  DCHECK_GE(precision, 0);
+  DCHECK_LE(precision, kMaxPrecision);
+  return DecimalTraits<BasicDecimal64>::powers_of_ten()[precision];
+}
+
+BasicDecimal64 BasicDecimal64::IncreaseScaleBy(int32_t increase_by) const {
+  DCHECK_GE(increase_by, 0);
+  DCHECK_LE(increase_by, kMaxScale);
+  return (*this) * DecimalTraits<BasicDecimal64>::powers_of_ten()[increase_by];
+}
+
+BasicDecimal64 BasicDecimal64::ReduceScaleBy(int32_t reduce_by, bool round) const {
+  DCHECK_GE(reduce_by, 0);
+  DCHECK_LE(reduce_by, kMaxScale);
+
+  if (reduce_by == 0) {
+    return *this;
+  }
+
+  BasicDecimal64 divisor(DecimalTraits<BasicDecimal64>::powers_of_ten()[reduce_by]);
+  BasicDecimal64 result;
+  BasicDecimal64 remainder;
+  auto s = Divide(divisor, &result, &remainder);
+  DCHECK_EQ(s, DecimalStatus::kSuccess);
+  if (round) {
+    auto divisor_half = DecimalTraits<BasicDecimal64>::half_powers_of_ten()[reduce_by];
+    if (remainder.Abs() >= divisor_half) {
+      result += Sign();
+    }
+  }
+  return result;
+}
+
+const BasicDecimal64& BasicDecimal64::GetScaleMultiplier(int32_t scale) {
+  DCHECK_GE(scale, 0);
+  DCHECK_LE(scale, kMaxScale);
+
+  return DecimalTraits<BasicDecimal64>::powers_of_ten()[scale];
+}
+
+const BasicDecimal64& BasicDecimal64::GetHalfScaleMultiplier(int32_t scale) {
+  DCHECK_GE(scale, 0);
+  DCHECK_LE(scale, kMaxScale);
+
+  return DecimalTraits<BasicDecimal64>::half_powers_of_ten()[scale];
+}
+
+bool BasicDecimal32::FitsInPrecision(int32_t precision) const {
+  DCHECK_GE(precision, 0);
+  DCHECK_LE(precision, kMaxPrecision);
+  return Abs(*this) < DecimalTraits<BasicDecimal32>::powers_of_ten()[precision];
+}
+
+bool BasicDecimal64::FitsInPrecision(int32_t precision) const {
+  DCHECK_GE(precision, 0);
+  DCHECK_LE(precision, kMaxPrecision);
+  return Abs(*this) < DecimalTraits<BasicDecimal64>::powers_of_ten()[precision];
+}
+
+bool operator<(const BasicDecimal32& left, const BasicDecimal32& right) {
+  return left.value() < right.value();
+}
+
+bool operator<=(const BasicDecimal32& left, const BasicDecimal32& right) {
+  return left.value() <= right.value();
+}
+
+bool operator>(const BasicDecimal32& left, const BasicDecimal32& right) {
+  return left.value() > right.value();
+}
+
+bool operator>=(const BasicDecimal32& left, const BasicDecimal32& right) {
+  return left.value() >= right.value();
+}
+
+BasicDecimal32 operator-(const BasicDecimal32& self) {
+  auto result = self;
+  return result.Negate();
+}
+
+BasicDecimal32 operator~(const BasicDecimal32& self) {
+  BasicDecimal32 result(~self.value());
+  return result;
+}
+
+BasicDecimal32 operator+(const BasicDecimal32& left, const BasicDecimal32& right) {
+  auto result = left;
+  return result += right;
+}
+
+BasicDecimal32 operator-(const BasicDecimal32& left, const BasicDecimal32& right) {
+  auto result = left;
+  return result -= right;
+}
+
+BasicDecimal32 operator*(const BasicDecimal32& left, const BasicDecimal32& right) {
+  auto result = left;
+  return result *= right;
+}
+
+BasicDecimal32 operator/(const BasicDecimal32& left, const BasicDecimal32& right) {
+  auto result = left;
+  return result /= right;
+}
+
+BasicDecimal32 operator%(const BasicDecimal32& left, const BasicDecimal32& right) {
+  BasicDecimal32 remainder;
+  BasicDecimal32 result;
+  auto s = left.Divide(right, &result, &remainder);
+  DCHECK_EQ(s, DecimalStatus::kSuccess);
+  return remainder;
+}
+
+bool operator<(const BasicDecimal64& left, const BasicDecimal64& right) {
+  return left.value() < right.value();
+}
+
+bool operator<=(const BasicDecimal64& left, const BasicDecimal64& right) {
+  return left.value() <= right.value();
+}
+
+bool operator>(const BasicDecimal64& left, const BasicDecimal64& right) {
+  return left.value() > right.value();
+}
+
+bool operator>=(const BasicDecimal64& left, const BasicDecimal64& right) {
+  return left.value() >= right.value();
+}
+
+BasicDecimal64 operator-(const BasicDecimal64& self) {
+  auto result = self;
+  return result.Negate();
+}
+
+BasicDecimal64 operator~(const BasicDecimal64& self) {
+  BasicDecimal64 result(~self.value());
+  return result;
+}
+
+BasicDecimal64 operator+(const BasicDecimal64& left, const BasicDecimal64& right) {
+  auto result = left;
+  return result += right;
+}
+
+BasicDecimal64 operator-(const BasicDecimal64& left, const BasicDecimal64& right) {
+  auto result = left;
+  return result -= right;
+}
+
+BasicDecimal64 operator*(const BasicDecimal64& left, const BasicDecimal64& right) {
+  auto result = left;
+  return result *= right;
+}
+
+BasicDecimal64 operator/(const BasicDecimal64& left, const BasicDecimal64& right) {
+  auto result = left;
+  return result /= right;
+}
+
+BasicDecimal64 operator%(const BasicDecimal64& left, const BasicDecimal64& right) {
+  BasicDecimal64 remainder;
+  BasicDecimal64 result;
+  auto s = left.Divide(right, &result, &remainder);
+  DCHECK_EQ(s, DecimalStatus::kSuccess);
+  return remainder;
+}
+
+template <typename BaseType>
+int32_t SmallBasicDecimal<BaseType>::CountLeadingBinaryZeros() const {
+  return bit_util::CountLeadingZeros(static_cast<std::make_unsigned_t<BaseType>>(value_));
+}
+
 // same as kDecimal128PowersOfTen[38] - 1
 static constexpr BasicDecimal128 kMaxDecimal128Value{5421010862427522170LL,
                                                      687399551400673280ULL - 1};
@@ -734,6 +1059,16 @@ DecimalStatus DecimalRescale(const DecimalClass& value, int32_t original_scale,
   return DecimalStatus::kSuccess;
 }
 
+DecimalStatus BasicDecimal32::Rescale(int32_t original_scale, int32_t new_scale,
+                                      BasicDecimal32* out) const {
+  return DecimalRescale(*this, original_scale, new_scale, out);
+}
+
+DecimalStatus BasicDecimal64::Rescale(int32_t original_scale, int32_t new_scale,
+                                      BasicDecimal64* out) const {
+  return DecimalRescale(*this, original_scale, new_scale, out);
+}
+
 DecimalStatus BasicDecimal128::Rescale(int32_t original_scale, int32_t new_scale,
                                        BasicDecimal128* out) const {
   return DecimalRescale(*this, original_scale, new_scale, out);
@@ -1050,5 +1385,7 @@ BasicDecimal256 operator/(const BasicDecimal256& left, const BasicDecimal256& ri
 // Explicitly instantiate template base class, for DLL linking on Windows
 template class GenericBasicDecimal<BasicDecimal128, 128>;
 template class GenericBasicDecimal<BasicDecimal256, 256>;
+template class SmallBasicDecimal<int32_t>;
+template class SmallBasicDecimal<int64_t>;
 
 }  // namespace arrow
diff --git a/cpp/src/arrow/util/basic_decimal.h b/cpp/src/arrow/util/basic_decimal.h
index d8a91ea76b390..fac40a46da8f6 100644
--- a/cpp/src/arrow/util/basic_decimal.h
+++ b/cpp/src/arrow/util/basic_decimal.h
@@ -18,6 +18,7 @@
 #pragma once
 
 #include <array>
+#include <climits>
 #include <cstdint>
 #include <cstring>
 #include <limits>
@@ -166,6 +167,396 @@ class ARROW_EXPORT GenericBasicDecimal {
   }
 };
 
+template <typename DigitType>
+class ARROW_EXPORT SmallBasicDecimal {
+ public:
+  static_assert(
+      std::is_same_v<DigitType, int32_t> || std::is_same_v<DigitType, int64_t>,
+      "for bitwidths larger than 64 bits use BasicDecimal128 and BasicDecimal256");
+
+  static constexpr int kMaxPrecision = std::numeric_limits<DigitType>::digits10;
+  static constexpr int kMaxScale = kMaxPrecision;
+  static constexpr int kBitWidth = sizeof(DigitType) * CHAR_BIT;
+  static constexpr int kByteWidth = sizeof(DigitType);
+
+  using WordArray = std::array<std::make_unsigned_t<DigitType>, 1>;
+
+  /// \brief Empty constructor creates a decimal with a value of 0.
+  constexpr SmallBasicDecimal() noexcept : value_(0) {}
+
+  /// \brief Create a decimal from any integer not wider than 64 bits.
+  template <typename T,
+            typename = typename std::enable_if<
+                std::is_integral<T>::value && (sizeof(T) <= sizeof(int64_t)), T>::type>
+  constexpr SmallBasicDecimal(T value) noexcept  // NOLINT(runtime/explicit)
+      : value_(static_cast<DigitType>(value)) {}
+
+  /// \brief Create a decimal from an array of bytes.
+  ///
+  /// Bytes are assumed to be in native-endian byte order.
+  explicit SmallBasicDecimal(const uint8_t* bytes) {
+    memcpy(&value_, bytes, sizeof(value_));
+  }
+
+  constexpr const WordArray native_endian_array() const {
+    return WordArray{static_cast<typename WordArray::value_type>(value_)};
+  }
+
+  constexpr const WordArray little_endian_array() const {
+    return bit_util::little_endian::FromNative(
+        WordArray{static_cast<typename WordArray::value_type>(value_)});
+  }
+
+  const uint8_t* native_endian_bytes() const {
+    return reinterpret_cast<const uint8_t*>(&value_);
+  }
+
+  uint8_t* mutable_native_endian_bytes() { return reinterpret_cast<uint8_t*>(&value_); }
+
+  /// \brief Return the raw bytes of the value in native-endian byte order.
+  std::array<uint8_t, kByteWidth> ToBytes() const {
+    std::array<uint8_t, kByteWidth> out{{0}};
+    memcpy(out.data(), &value_, kByteWidth);
+    return out;
+  }
+
+  /// \brief Copy the raw bytes of the value in native-endian byte order
+  void ToBytes(uint8_t* out) const { memcpy(out, &value_, kByteWidth); }
+
+  /// \brief Return 1 if positive or 0, -1 if strictly negative
+  int64_t Sign() const { return 1 | (value_ >> (kBitWidth - 1)); }
+
+  bool IsNegative() const { return value_ < 0; }
+
+  explicit operator bool() const { return value_ != 0; }
+
+  friend bool operator==(const SmallBasicDecimal& left, const SmallBasicDecimal& right) {
+    return left.value_ == right.value_;
+  }
+
+  friend bool operator!=(const SmallBasicDecimal& left, const SmallBasicDecimal& right) {
+    return left.value_ != right.value_;
+  }
+
+  DigitType value() const { return value_; }
+
+  /// \brief count the number of leading binary zeroes.
+  int32_t CountLeadingBinaryZeros() const;
+
+  constexpr uint64_t low_bits() const { return static_cast<uint64_t>(value_); }
+
+ protected:
+  DigitType value_;
+};
+
+class BasicDecimal32;
+class BasicDecimal64;
+
+ARROW_EXPORT bool operator<(const BasicDecimal32& left, const BasicDecimal32& right);
+ARROW_EXPORT bool operator<=(const BasicDecimal32& left, const BasicDecimal32& right);
+ARROW_EXPORT bool operator>(const BasicDecimal32& left, const BasicDecimal32& right);
+ARROW_EXPORT bool operator>=(const BasicDecimal32& left, const BasicDecimal32& right);
+
+ARROW_EXPORT BasicDecimal32 operator-(const BasicDecimal32& self);
+ARROW_EXPORT BasicDecimal32 operator~(const BasicDecimal32& self);
+ARROW_EXPORT BasicDecimal32 operator+(const BasicDecimal32& left,
+                                      const BasicDecimal32& right);
+ARROW_EXPORT BasicDecimal32 operator-(const BasicDecimal32& left,
+                                      const BasicDecimal32& right);
+ARROW_EXPORT BasicDecimal32 operator*(const BasicDecimal32& left,
+                                      const BasicDecimal32& right);
+ARROW_EXPORT BasicDecimal32 operator/(const BasicDecimal32& left,
+                                      const BasicDecimal32& right);
+ARROW_EXPORT BasicDecimal32 operator%(const BasicDecimal32& left,
+                                      const BasicDecimal32& right);
+
+class ARROW_EXPORT BasicDecimal32 : public SmallBasicDecimal<int32_t> {
+ public:
+  using SmallBasicDecimal<int32_t>::SmallBasicDecimal;
+  using ValueType = int32_t;
+
+  /// \brief Negate the current value (in-place)
+  BasicDecimal32& Negate() {
+    value_ = -value_;
+    return *this;
+  }
+
+  /// \brief Absolute value (in-place)
+  BasicDecimal32& Abs() { return *this < 0 ? Negate() : *this; }
+
+  /// \brief Absolute value
+  static BasicDecimal32 Abs(const BasicDecimal32& in) {
+    BasicDecimal32 result(in);
+    return result.Abs();
+  }
+
+  /// \brief Add a number to this one. The result is truncated to 32 bits.
+  BasicDecimal32& operator+=(const BasicDecimal32& right) {
+    value_ += right.value_;
+    return *this;
+  }
+
+  /// \brief Subtract a number from this one. The result is truncated to 32 bits.
+  BasicDecimal32& operator-=(const BasicDecimal32& right) {
+    value_ -= right.value_;
+    return *this;
+  }
+
+  /// \brief Multiply this number by another. The result is truncated to 32 bits.
+  BasicDecimal32& operator*=(const BasicDecimal32& right) {
+    value_ *= static_cast<uint64_t>(right.value_);
+    return *this;
+  }
+
+  /// \brief Divide this number by the divisor and return the result.
+  ///
+  /// This operation is not destructive.
+  /// The answer rounds to zero. Signs work like:
+  ///   21 /  5 ->  4,  1
+  ///  -21 /  5 -> -4, -1
+  ///   21 / -5 -> -4,  1
+  ///  -21 / -5 ->  4, -1
+  /// \param[in] divisor the number to divide by
+  /// \param[out] result the quotient
+  /// \param[out] remainder the remainder after the division
+  DecimalStatus Divide(const BasicDecimal32& divisor, BasicDecimal32* result,
+                       BasicDecimal32* remainder) const;
+
+  /// \brief In-place division
+  BasicDecimal32& operator/=(const BasicDecimal32& right) {
+    value_ /= right.value_;
+    return *this;
+  }
+
+  /// \brief Bitwise "or" between two BasicDecimal32s
+  BasicDecimal32& operator|=(const BasicDecimal32& right) {
+    value_ |= right.value_;
+    return *this;
+  }
+
+  /// \brief Bitwise "and" between two BasicDecimal32s
+  BasicDecimal32& operator&=(const BasicDecimal32& right) {
+    value_ &= right.value_;
+    return *this;
+  }
+  /// \brief Shift left by the given number of bits.
+  BasicDecimal32& operator<<=(uint32_t bits);
+
+  BasicDecimal32 operator<<(uint32_t bits) const {
+    auto res = *this;
+    res <<= bits;
+    return res;
+  }
+
+  /// \brief Shift right by the given number of bits.
+  ///
+  /// Negative values will sign-extend
+  BasicDecimal32& operator>>=(uint32_t bits);
+
+  BasicDecimal32 operator>>(uint32_t bits) const {
+    auto res = *this;
+    res >>= bits;
+    return res;
+  }
+
+  /// \brief Convert BasicDecimal32 from one scale to another
+  DecimalStatus Rescale(int32_t original_scale, int32_t new_scale,
+                        BasicDecimal32* out) const;
+
+  void GetWholeAndFraction(int scale, BasicDecimal32* whole,
+                           BasicDecimal32* fraction) const;
+
+  /// \brief Scale up.
+  BasicDecimal32 IncreaseScaleBy(int32_t increase_by) const;
+
+  /// \brief Scale down.
+  ///
+  /// - If 'round' is true, the right-most digits are dropped and the result value is
+  ///   rounded up (+1 for +ve, -1 for -ve) based on the value of the dropped digits
+  ///   (>= 10^reduce_by / 2).
+  /// - If 'round' is false, the right-most digits are simply dropped.
+  BasicDecimal32 ReduceScaleBy(int32_t reduce_by, bool round = true) const;
+
+  /// \brief Whether this number fits in the given precision
+  ///
+  /// Return true if the number of significant digits is less or equal to 'precision'.
+  bool FitsInPrecision(int32_t precision) const;
+
+  /// \brief Get the maximum valid unscaled decimal value.
+  static const BasicDecimal32& GetMaxValue();
+  /// \brief Get the maximum valid unscaled decimal value for the given precision.
+  static BasicDecimal32 GetMaxValue(int32_t precision);
+
+  /// \brief Get the maximum decimal value (is not a valid value).
+  static constexpr BasicDecimal32 GetMaxSentinel() {
+    return BasicDecimal32(std::numeric_limits<int32_t>::max());
+  }
+
+  /// \brief Get the minimum decimal value (is not a valid value).
+  static constexpr BasicDecimal32 GetMinSentinel() {
+    return BasicDecimal32(std::numeric_limits<int32_t>::min());
+  }
+
+  /// \brief Scale multiplier for a given scale value.
+  static const BasicDecimal32& GetScaleMultiplier(int32_t scale);
+  /// \brief Half-scale multiplier for a given scale value.
+  static const BasicDecimal32& GetHalfScaleMultiplier(int32_t scale);
+
+  explicit operator BasicDecimal64() const;
+};
+
+ARROW_EXPORT bool operator<(const BasicDecimal64& left, const BasicDecimal64& right);
+ARROW_EXPORT bool operator<=(const BasicDecimal64& left, const BasicDecimal64& right);
+ARROW_EXPORT bool operator>(const BasicDecimal64& left, const BasicDecimal64& right);
+ARROW_EXPORT bool operator>=(const BasicDecimal64& left, const BasicDecimal64& right);
+
+ARROW_EXPORT BasicDecimal64 operator-(const BasicDecimal64& self);
+ARROW_EXPORT BasicDecimal64 operator~(const BasicDecimal64& self);
+ARROW_EXPORT BasicDecimal64 operator+(const BasicDecimal64& left,
+                                      const BasicDecimal64& right);
+ARROW_EXPORT BasicDecimal64 operator-(const BasicDecimal64& left,
+                                      const BasicDecimal64& right);
+ARROW_EXPORT BasicDecimal64 operator*(const BasicDecimal64& left,
+                                      const BasicDecimal64& right);
+ARROW_EXPORT BasicDecimal64 operator/(const BasicDecimal64& left,
+                                      const BasicDecimal64& right);
+ARROW_EXPORT BasicDecimal64 operator%(const BasicDecimal64& left,
+                                      const BasicDecimal64& right);
+
+class ARROW_EXPORT BasicDecimal64 : public SmallBasicDecimal<int64_t> {
+ public:
+  using SmallBasicDecimal<int64_t>::SmallBasicDecimal;
+  using ValueType = int64_t;
+
+  /// \brief Negate the current value (in-place)
+  BasicDecimal64& Negate() {
+    value_ = -value_;
+    return *this;
+  }
+
+  /// \brief Absolute value (in-place)
+  BasicDecimal64& Abs() { return *this < 0 ? Negate() : *this; }
+
+  /// \brief Absolute value
+  static BasicDecimal64 Abs(const BasicDecimal64& in) {
+    BasicDecimal64 result(in);
+    return result.Abs();
+  }
+
+  /// \brief Add a number to this one. The result is truncated to 32 bits.
+  BasicDecimal64& operator+=(const BasicDecimal64& right) {
+    value_ += right.value_;
+    return *this;
+  }
+
+  /// \brief Subtract a number from this one. The result is truncated to 32 bits.
+  BasicDecimal64& operator-=(const BasicDecimal64& right) {
+    value_ -= right.value_;
+    return *this;
+  }
+
+  /// \brief Multiply this number by another. The result is truncated to 32 bits.
+  BasicDecimal64& operator*=(const BasicDecimal64& right) {
+    value_ *= static_cast<uint64_t>(right.value_);
+    return *this;
+  }
+
+  /// \brief Divide this number by the divisor and return the result.
+  ///
+  /// This operation is not destructive.
+  /// The answer rounds to zero. Signs work like:
+  ///   21 /  5 ->  4,  1
+  ///  -21 /  5 -> -4, -1
+  ///   21 / -5 -> -4,  1
+  ///  -21 / -5 ->  4, -1
+  /// \param[in] divisor the number to divide by
+  /// \param[out] result the quotient
+  /// \param[out] remainder the remainder after the division
+  DecimalStatus Divide(const BasicDecimal64& divisor, BasicDecimal64* result,
+                       BasicDecimal64* remainder) const;
+
+  /// \brief In-place division
+  BasicDecimal64& operator/=(const BasicDecimal64& right) {
+    value_ /= right.value_;
+    return *this;
+  }
+
+  /// \brief Bitwise "or" between two BasicDecimal64s
+  BasicDecimal64& operator|=(const BasicDecimal64& right) {
+    value_ |= right.value_;
+    return *this;
+  }
+
+  /// \brief Bitwise "and" between two BasicDecimal64s
+  BasicDecimal64& operator&=(const BasicDecimal64& right) {
+    value_ &= right.value_;
+    return *this;
+  }
+
+  /// \brief Shift left by the given number of bits.
+  BasicDecimal64& operator<<=(uint32_t bits);
+
+  BasicDecimal64 operator<<(uint32_t bits) const {
+    auto res = *this;
+    res <<= bits;
+    return res;
+  }
+
+  /// \brief Shift right by the given number of bits.
+  ///
+  /// Negative values will sign-extend
+  BasicDecimal64& operator>>=(uint32_t bits);
+
+  BasicDecimal64 operator>>(uint32_t bits) const {
+    auto res = *this;
+    res >>= bits;
+    return res;
+  }
+
+  /// \brief Convert BasicDecimal32 from one scale to another
+  DecimalStatus Rescale(int32_t original_scale, int32_t new_scale,
+                        BasicDecimal64* out) const;
+
+  void GetWholeAndFraction(int scale, BasicDecimal64* whole,
+                           BasicDecimal64* fraction) const;
+
+  /// \brief Scale up.
+  BasicDecimal64 IncreaseScaleBy(int32_t increase_by) const;
+
+  /// \brief Scale down.
+  ///
+  /// - If 'round' is true, the right-most digits are dropped and the result value is
+  ///   rounded up (+1 for +ve, -1 for -ve) based on the value of the dropped digits
+  ///   (>= 10^reduce_by / 2).
+  /// - If 'round' is false, the right-most digits are simply dropped.
+  BasicDecimal64 ReduceScaleBy(int32_t reduce_by, bool round = true) const;
+
+  /// \brief Whether this number fits in the given precision
+  ///
+  /// Return true if the number of significant digits is less or equal to 'precision'.
+  bool FitsInPrecision(int32_t precision) const;
+
+  /// \brief Get the maximum valid unscaled decimal value.
+  static const BasicDecimal64& GetMaxValue();
+  /// \brief Get the maximum valid unscaled decimal value for the given precision.
+  static BasicDecimal64 GetMaxValue(int32_t precision);
+
+  /// \brief Get the maximum decimal value (is not a valid value).
+  static constexpr BasicDecimal64 GetMaxSentinel() {
+    return BasicDecimal64(std::numeric_limits<int32_t>::max());
+  }
+
+  /// \brief Get the minimum decimal value (is not a valid value).
+  static constexpr BasicDecimal64 GetMinSentinel() {
+    return BasicDecimal64(std::numeric_limits<int32_t>::min());
+  }
+
+  /// \brief Scale multiplier for a given scale value.
+  static const BasicDecimal64& GetScaleMultiplier(int32_t scale);
+  /// \brief Half-scale multiplier for a given scale value.
+  static const BasicDecimal64& GetHalfScaleMultiplier(int32_t scale);
+};
+
 /// Represents a signed 128-bit integer in two's complement.
 ///
 /// This class is also compiled into LLVM IR - so, it should not have cpp references like
diff --git a/cpp/src/arrow/util/decimal.cc b/cpp/src/arrow/util/decimal.cc
index c8457eae8ed33..1cd62184ccbe3 100644
--- a/cpp/src/arrow/util/decimal.cc
+++ b/cpp/src/arrow/util/decimal.cc
@@ -71,6 +71,7 @@ struct BaseDecimalRealConversion {
 template <typename DecimalType, typename Derived>
 struct DecimalRealConversion : public BaseDecimalRealConversion {
   using DecimalTypeTraits = DecimalTraits<DecimalType>;
+
   static constexpr int kMaxPrecision = DecimalType::kMaxPrecision;
   static constexpr int kMaxScale = DecimalType::kMaxScale;
 
@@ -92,6 +93,12 @@ struct DecimalRealConversion : public BaseDecimalRealConversion {
     constexpr int kMantissaBits = RealTraits<Real>::kMantissaBits;
     constexpr int kMantissaDigits = RealTraits<Real>::kMantissaDigits;
 
+    // to avoid precision and rounding issues, we'll unconditionally
+    // throw Decimal32 to the approx algorithm instead. (GH-44216)
+    if constexpr (std::is_base_of_v<BasicDecimal32, DecimalType>) {
+      return Derived::FromPositiveRealApprox(real, precision, scale);
+    }
+
     // Problem statement: construct the Decimal with the value
     // closest to `real * 10^scale`.
     if (scale < 0) {
@@ -109,6 +116,13 @@ struct DecimalRealConversion : public BaseDecimalRealConversion {
       return OverflowError(real, precision, scale);
     }
 
+    // The algorithm below requires the destination decimal type
+    // to be strictly more precise than the source float type
+    // (see `kSafeMulByTenTo` calculation).
+    if constexpr (kMaxPrecision <= kMantissaDigits) {
+      return Derived::FromPositiveRealApprox(real, precision, scale);
+    }
+
     // 2. Losslessly convert `real` to `mant * 2**k`
     int binary_exp = 0;
     const Real real_mant = std::frexp(real, &binary_exp);
@@ -237,6 +251,121 @@ struct DecimalRealConversion : public BaseDecimalRealConversion {
   }
 };
 
+struct Decimal32RealConversion
+    : public DecimalRealConversion<Decimal32, Decimal32RealConversion> {
+  using Base = DecimalRealConversion<Decimal32, Decimal32RealConversion>;
+  using Base::LargePowerOfTen;
+  using Base::PowerOfTen;
+
+  static Decimal32 RoundedRightShift(const Decimal32& x, int bits) {
+    // currently we *only* push to the Approx method for Decimal32
+    // so this should never get called.
+    DCHECK(false);
+    return x;
+  }
+
+  template <typename Real>
+  static Result<Decimal32> FromPositiveRealApprox(Real real, int32_t precision,
+                                                  int32_t scale) {
+    const auto x = std::nearbyint(real * PowerOfTen<Real>(scale));
+    const auto max_abs = PowerOfTen<Real>(precision);
+    if (x <= -max_abs || x >= max_abs) {
+      return OverflowError(real, precision, scale);
+    }
+
+    return Decimal32(static_cast<int32_t>(x));
+  }
+
+  template <typename Real>
+  static Real ToRealPositiveNoSplit(const Decimal32& decimal, int32_t scale) {
+    Real x = static_cast<Real>(decimal.value());
+    x *= LargePowerOfTen<Real>(-scale);
+    return x;
+  }
+
+  template <typename Real>
+  static Real ToRealPositive(const Decimal32& decimal, int32_t scale) {
+    if (scale <= 0 || uint64_t(decimal.value()) <= RealTraits<Real>::kMaxPreciseInteger) {
+      return ToRealPositiveNoSplit<Real>(decimal, scale);
+    }
+
+    Decimal32 whole_decimal, fraction_decimal;
+    decimal.GetWholeAndFraction(scale, &whole_decimal, &fraction_decimal);
+
+    Real whole = ToRealPositiveNoSplit<Real>(whole_decimal, 0);
+    Real fraction = ToRealPositiveNoSplit<Real>(fraction_decimal, scale);
+
+    return whole + fraction;
+  }
+};
+
+struct Decimal64RealConversion
+    : public DecimalRealConversion<Decimal64, Decimal64RealConversion> {
+  using Base = DecimalRealConversion<Decimal64, Decimal64RealConversion>;
+  using Base::LargePowerOfTen;
+  using Base::PowerOfTen;
+
+  static Decimal64 RoundedRightShift(const Decimal64& x, int bits) {
+    if (bits == 0) {
+      return x;
+    }
+
+    int64_t result = x.value();
+    uint64_t shifted = 0;
+    if (bits > 0) {
+      shifted = (static_cast<uint64_t>(result) << (64 - bits));
+      result >>= bits;
+    }
+    constexpr uint64_t kHalf = 0x8000000000000000ULL;
+    if (shifted > kHalf) {
+      // strictly more than half => round up
+      result += 1;
+    } else if (shifted == kHalf) {
+      // exactly half => round to even
+      if ((result & 1) != 0) {
+        result += 1;
+      }
+    } else {
+      // strictly less than half => round down
+    }
+    return Decimal64(result);
+  }
+
+  template <typename Real>
+  static Result<Decimal64> FromPositiveRealApprox(Real real, int32_t precision,
+                                                  int32_t scale) {
+    const auto x = std::nearbyint(real * PowerOfTen<Real>(scale));
+    const auto max_abs = PowerOfTen<Real>(precision);
+    if (x <= -max_abs || x >= max_abs) {
+      return OverflowError(real, precision, scale);
+    }
+
+    return Decimal64(static_cast<int64_t>(x));
+  }
+
+  template <typename Real>
+  static Real ToRealPositiveNoSplit(const Decimal64& decimal, int32_t scale) {
+    Real x = static_cast<Real>(decimal.value());
+    x *= LargePowerOfTen<Real>(-scale);
+    return x;
+  }
+
+  template <typename Real>
+  static Real ToRealPositive(const Decimal64& decimal, int32_t scale) {
+    if (scale <= 0 || uint64_t(decimal.value()) <= RealTraits<Real>::kMaxPreciseInteger) {
+      return ToRealPositiveNoSplit<Real>(decimal, scale);
+    }
+
+    Decimal64 whole_decimal, fraction_decimal;
+    decimal.GetWholeAndFraction(scale, &whole_decimal, &fraction_decimal);
+
+    Real whole = ToRealPositiveNoSplit<Real>(whole_decimal, 0);
+    Real fraction = ToRealPositiveNoSplit<Real>(fraction_decimal, scale);
+
+    return whole + fraction;
+  }
+};
+
 struct Decimal128RealConversion
     : public DecimalRealConversion<Decimal128, Decimal128RealConversion> {
   using Base = DecimalRealConversion<Decimal128, Decimal128RealConversion>;
@@ -342,6 +471,70 @@ struct Decimal128RealConversion
 
 }  // namespace
 
+Decimal32::Decimal32(const std::string& str) : Decimal32() {
+  *this = FromString(str).ValueOrDie();
+}
+
+Result<Decimal32> Decimal32::FromReal(float x, int32_t precision, int32_t scale) {
+  return Decimal32RealConversion::FromReal(x, precision, scale);
+}
+
+Result<Decimal32> Decimal32::FromReal(double x, int32_t precision, int32_t scale) {
+  return Decimal32RealConversion::FromReal(x, precision, scale);
+}
+
+float Decimal32::ToFloat(int32_t scale) const {
+  return Decimal32RealConversion::ToReal<float>(*this, scale);
+}
+
+double Decimal32::ToDouble(int32_t scale) const {
+  return Decimal32RealConversion::ToReal<double>(*this, scale);
+}
+
+std::string Decimal32::ToIntegerString() const {
+  std::string result;
+  internal::StringFormatter<Int32Type> format;
+  format(value_, [&result](std::string_view formatted) {
+    result.append(formatted.data(), formatted.size());
+  });
+  return result;
+}
+
+Decimal32::operator int64_t() const { return static_cast<int64_t>(value_); }
+
+Decimal32::operator Decimal64() const { return Decimal64(static_cast<int64_t>(value_)); }
+
+Decimal64::Decimal64(const std::string& str) : Decimal64() {
+  *this = FromString(str).ValueOrDie();
+}
+
+Result<Decimal64> Decimal64::FromReal(float x, int32_t precision, int32_t scale) {
+  return Decimal64RealConversion::FromReal(x, precision, scale);
+}
+
+Result<Decimal64> Decimal64::FromReal(double x, int32_t precision, int32_t scale) {
+  return Decimal64RealConversion::FromReal(x, precision, scale);
+}
+
+float Decimal64::ToFloat(int32_t scale) const {
+  return Decimal64RealConversion::ToReal<float>(*this, scale);
+}
+
+double Decimal64::ToDouble(int32_t scale) const {
+  return Decimal64RealConversion::ToReal<double>(*this, scale);
+}
+
+std::string Decimal64::ToIntegerString() const {
+  std::string result;
+  internal::StringFormatter<Int64Type> format;
+  format(value_, [&result](std::string_view formatted) {
+    result.append(formatted.data(), formatted.size());
+  });
+  return result;
+}
+
+Decimal64::operator int64_t() const { return static_cast<int64_t>(value_); }
+
 Decimal128::Decimal128(const std::string& str) : Decimal128() {
   *this = Decimal128::FromString(str).ValueOrDie();
 }
@@ -512,6 +705,26 @@ static void AdjustIntegerStringWithScale(int32_t scale, std::string* str) {
   str->at(is_negative_offset + 1) = '.';
 }
 
+std::string Decimal32::ToString(int32_t scale) const {
+  if (ARROW_PREDICT_FALSE(scale < -kMaxScale || scale > kMaxScale)) {
+    return "<scale out of range, cannot format Decimal32 value>";
+  }
+
+  std::string str(ToIntegerString());
+  AdjustIntegerStringWithScale(scale, &str);
+  return str;
+}
+
+std::string Decimal64::ToString(int32_t scale) const {
+  if (ARROW_PREDICT_FALSE(scale < -kMaxScale || scale > kMaxScale)) {
+    return "<scale out of range, cannot format Decimal64 value>";
+  }
+
+  std::string str(ToIntegerString());
+  AdjustIntegerStringWithScale(scale, &str);
+  return str;
+}
+
 std::string Decimal128::ToString(int32_t scale) const {
   if (ARROW_PREDICT_FALSE(scale < -kMaxScale || scale > kMaxScale)) {
     return "<scale out of range, cannot format Decimal128 value>";
@@ -697,8 +910,133 @@ Status DecimalFromString(const char* type_name, std::string_view s, Decimal* out
   return Status::OK();
 }
 
+template <typename DecimalClass>
+Status SimpleDecimalFromString(const char* type_name, std::string_view s,
+                               DecimalClass* out, int32_t* precision, int32_t* scale) {
+  if (s.empty()) {
+    return Status::Invalid("Empty string cannot be converted to ", type_name);
+  }
+
+  DecimalComponents dec;
+  if (!ParseDecimalComponents(s.data(), s.size(), &dec)) {
+    return Status::Invalid("The string '", s, "' is not a valid ", type_name, " number");
+  }
+
+  // count number of significant digits (without leading zeros)
+  size_t first_non_zero = dec.whole_digits.find_first_not_of('0');
+  size_t significant_digits = dec.fractional_digits.size();
+  if (first_non_zero != std::string::npos) {
+    significant_digits += dec.whole_digits.size() - first_non_zero;
+  }
+  int32_t parsed_precision = static_cast<int32_t>(significant_digits);
+
+  int32_t parsed_scale = 0;
+  if (dec.has_exponent) {
+    auto adjusted_exponent = dec.exponent;
+    parsed_scale =
+        -adjusted_exponent + static_cast<int32_t>(dec.fractional_digits.size());
+  } else {
+    parsed_scale = static_cast<int32_t>(dec.fractional_digits.size());
+  }
+
+  if (out != nullptr) {
+    uint64_t value{0};
+    ShiftAndAdd(dec.whole_digits, &value, 1);
+    ShiftAndAdd(dec.fractional_digits, &value, 1);
+    if (value > static_cast<uint64_t>(
+                    std::numeric_limits<typename DecimalClass::ValueType>::max())) {
+      return Status::Invalid("The string '", s, "' cannot be represented as ", type_name);
+    }
+
+    *out = DecimalClass(value);
+    if (dec.sign == '-') {
+      out->Negate();
+    }
+  }
+
+  if (parsed_scale < 0) {
+    // Force the scale to zero, to avoid negative scales (due to compatibility issues
+    // with external systems such as databases)
+    if (-parsed_scale > DecimalClass::kMaxScale) {
+      return Status::Invalid("The string '", s, "' cannot be represented as ", type_name);
+    }
+    if (out != nullptr) {
+      *out *= DecimalClass::GetScaleMultiplier(-parsed_scale);
+    }
+    parsed_precision -= parsed_scale;
+    parsed_scale = 0;
+  }
+
+  if (precision != nullptr) {
+    *precision = parsed_precision;
+  }
+  if (scale != nullptr) {
+    *scale = parsed_scale;
+  }
+
+  return Status::OK();
+}
+
 }  // namespace
 
+Status Decimal32::FromString(std::string_view s, Decimal32* out, int32_t* precision,
+                             int32_t* scale) {
+  return SimpleDecimalFromString("decimal32", s, out, precision, scale);
+}
+
+Status Decimal32::FromString(const std::string& s, Decimal32* out, int32_t* precision,
+                             int32_t* scale) {
+  return FromString(std::string_view(s), out, precision, scale);
+}
+
+Status Decimal32::FromString(const char* s, Decimal32* out, int32_t* precision,
+                             int32_t* scale) {
+  return FromString(std::string_view(s), out, precision, scale);
+}
+
+Result<Decimal32> Decimal32::FromString(std::string_view s) {
+  Decimal32 out;
+  RETURN_NOT_OK(FromString(s, &out, nullptr, nullptr));
+  return out;
+}
+
+Result<Decimal32> Decimal32::FromString(const std::string& s) {
+  return FromString(std::string_view(s));
+}
+
+Result<Decimal32> Decimal32::FromString(const char* s) {
+  return FromString(std::string_view(s));
+}
+
+Status Decimal64::FromString(std::string_view s, Decimal64* out, int32_t* precision,
+                             int32_t* scale) {
+  return SimpleDecimalFromString("decimal64", s, out, precision, scale);
+}
+
+Status Decimal64::FromString(const std::string& s, Decimal64* out, int32_t* precision,
+                             int32_t* scale) {
+  return FromString(std::string_view(s), out, precision, scale);
+}
+
+Status Decimal64::FromString(const char* s, Decimal64* out, int32_t* precision,
+                             int32_t* scale) {
+  return FromString(std::string_view(s), out, precision, scale);
+}
+
+Result<Decimal64> Decimal64::FromString(std::string_view s) {
+  Decimal64 out;
+  RETURN_NOT_OK(FromString(s, &out, nullptr, nullptr));
+  return out;
+}
+
+Result<Decimal64> Decimal64::FromString(const std::string& s) {
+  return FromString(std::string_view(s));
+}
+
+Result<Decimal64> Decimal64::FromString(const char* s) {
+  return FromString(std::string_view(s));
+}
+
 Status Decimal128::FromString(std::string_view s, Decimal128* out, int32_t* precision,
                               int32_t* scale) {
   return DecimalFromString("decimal128", s, out, precision, scale);
@@ -742,6 +1080,60 @@ static inline uint64_t UInt64FromBigEndian(const uint8_t* bytes, int32_t length)
   return ::arrow::bit_util::FromBigEndian(result);
 }
 
+Result<Decimal32> Decimal32::FromBigEndian(const uint8_t* bytes, int32_t length) {
+  static constexpr int32_t kMinDecimalBytes = 1;
+  static constexpr int32_t kMaxDecimalBytes = 4;
+
+  if (ARROW_PREDICT_FALSE(length < kMinDecimalBytes || length > kMaxDecimalBytes)) {
+    return Status::Invalid("Length of byte array passed to Decimal32::FromBigEndian was ",
+                           length, ", but must be between ", kMinDecimalBytes, " and ",
+                           kMaxDecimalBytes);
+  }
+
+  const bool is_negative = static_cast<int8_t>(bytes[0]) < 0;
+  int32_t result = is_negative ? 0xffffffff : 0;
+  memcpy(reinterpret_cast<uint8_t*>(&result) + kMaxDecimalBytes - length, bytes, length);
+
+  const auto value = bit_util::FromBigEndian(result);
+  return Decimal32(value);
+}
+
+Status Decimal32::ToArrowStatus(DecimalStatus dstatus) const {
+  return arrow::ToArrowStatus(dstatus, 32);
+}
+
+std::ostream& operator<<(std::ostream& os, const Decimal32& decimal) {
+  os << decimal.ToIntegerString();
+  return os;
+}
+
+Result<Decimal64> Decimal64::FromBigEndian(const uint8_t* bytes, int32_t length) {
+  static constexpr int32_t kMinDecimalBytes = 1;
+  static constexpr int32_t kMaxDecimalBytes = 8;
+
+  if (ARROW_PREDICT_FALSE(length < kMinDecimalBytes || length > kMaxDecimalBytes)) {
+    return Status::Invalid("Length of byte array passed to Decimal64::FromBigEndian was ",
+                           length, ", but must be between ", kMinDecimalBytes, " and ",
+                           kMaxDecimalBytes);
+  }
+
+  const bool is_negative = static_cast<int8_t>(bytes[0]) < 0;
+  int64_t result = is_negative ? 0xffffffffffffffffL : 0;
+  memcpy(reinterpret_cast<uint8_t*>(&result) + kMaxDecimalBytes - length, bytes, length);
+
+  const auto value = bit_util::FromBigEndian(result);
+  return Decimal64(value);
+}
+
+Status Decimal64::ToArrowStatus(DecimalStatus dstatus) const {
+  return arrow::ToArrowStatus(dstatus, 64);
+}
+
+std::ostream& operator<<(std::ostream& os, const Decimal64& decimal) {
+  os << decimal.ToIntegerString();
+  return os;
+}
+
 Result<Decimal128> Decimal128::FromBigEndian(const uint8_t* bytes, int32_t length) {
   static constexpr int32_t kMinDecimalBytes = 1;
   static constexpr int32_t kMaxDecimalBytes = 16;
@@ -1056,4 +1448,5 @@ std::ostream& operator<<(std::ostream& os, const Decimal256& decimal) {
   os << decimal.ToIntegerString();
   return os;
 }
+
 }  // namespace arrow
diff --git a/cpp/src/arrow/util/decimal.h b/cpp/src/arrow/util/decimal.h
index 14c7103d5ac0d..640dc9aec157c 100644
--- a/cpp/src/arrow/util/decimal.h
+++ b/cpp/src/arrow/util/decimal.h
@@ -31,6 +31,243 @@
 
 namespace arrow {
 
+class Decimal64;
+
+/// Represents a signed 32-bit decimal value in two's complement.
+/// Calulations wrap around and overflow is ignored.
+/// The max decimal precision that can be safely represented is
+/// 9 significant digits.
+///
+/// The implementation is split into two parts :
+///
+/// 1. BasicDecimal32
+///    - can be safely compiled to IR without references to libstdc++
+/// 2. Decimal32
+///    - has additional functionality on top of BasicDecimal32 to deal with
+///      strings and streams
+class ARROW_EXPORT Decimal32 : public BasicDecimal32 {
+ public:
+  /// \cond FALSE
+  // (need to avoid a duplicate definition in sphinx)
+  using BasicDecimal32::BasicDecimal32;
+  /// \endcond
+
+  /// \brief constructor creates a Decimal32 from a BasicDecimal32
+  constexpr Decimal32(const BasicDecimal32& value) noexcept  // NOLINT runtime/explicit
+      : BasicDecimal32(value) {}
+
+  /// \brief Parse the number from a base 10 string representation
+  explicit Decimal32(const std::string& value);
+
+  /// \brief Empty constructor creates a Decimal32 with a value of 0
+  /// this is required for some older compilers
+  constexpr Decimal32() noexcept : BasicDecimal32() {}
+
+  /// \brief Divide this number by right and return the result.
+  ///
+  /// This operation is not destructive.
+  /// The answer rounds to zero. Signs work like:
+  ///   21 /  5 ->  4,  1
+  ///  -21 /  5 -> -4, -1
+  ///   21 / -5 -> -4,  1
+  ///  -21 / -5 ->  4, -1
+  /// \param[in] divisor the number to divide by
+  /// \return the pair of the quotient and the remainder
+  Result<std::pair<Decimal32, Decimal32>> Divide(const Decimal32& divisor) const {
+    std::pair<Decimal32, Decimal32> result;
+    auto dstatus = BasicDecimal32::Divide(divisor, &result.first, &result.second);
+    ARROW_RETURN_NOT_OK(ToArrowStatus(dstatus));
+    return result;
+  }
+
+  /// \brief Convert the Decimal32 value to a base 10 decimal string with the given scale
+  std::string ToString(int32_t scale) const;
+
+  /// \brief Convert the value to an integer string
+  std::string ToIntegerString() const;
+
+  /// \brief Cast this value to an int64_t
+  explicit operator int64_t() const;
+
+  explicit operator Decimal64() const;
+
+  /// \brief Convert a decimal string to a Decimal value, optionally including
+  /// precision and scale if they're passed in and not null.
+  static Status FromString(std::string_view s, Decimal32* out, int32_t* precision,
+                           int32_t* scale = NULLPTR);
+  static Status FromString(const std::string& s, Decimal32* out, int32_t* precision,
+                           int32_t* scale = NULLPTR);
+  static Status FromString(const char* s, Decimal32* out, int32_t* precision,
+                           int32_t* scale = NULLPTR);
+  static Result<Decimal32> FromString(std::string_view s);
+  static Result<Decimal32> FromString(const std::string& s);
+  static Result<Decimal32> FromString(const char* s);
+
+  static Result<Decimal32> FromReal(double real, int32_t precision, int32_t scale);
+  static Result<Decimal32> FromReal(float real, int32_t precision, int32_t scale);
+
+  /// \brief Convert from a big-endian byte representation. The length must be
+  ///        between 1 and 4
+  /// \return error statis if the length is an invalid value
+  static Result<Decimal32> FromBigEndian(const uint8_t* data, int32_t length);
+
+  /// \brief Convert Decimal32 from one scale to another
+  Result<Decimal32> Rescale(int32_t original_scale, int32_t new_scale) const {
+    Decimal32 out;
+    auto dstatus = BasicDecimal32::Rescale(original_scale, new_scale, &out);
+    ARROW_RETURN_NOT_OK(ToArrowStatus(dstatus));
+    return out;
+  }
+
+  /// \brief Convert to a signed integer
+  template <typename T, typename = internal::EnableIfIsOneOf<T, int32_t, int64_t>>
+  Result<T> ToInteger() const {
+    return static_cast<T>(value_);
+  }
+
+  /// \brief Convert to a signed integer
+  template <typename T, typename = internal::EnableIfIsOneOf<T, int32_t, int64_t>>
+  Status ToInteger(T* out) const {
+    return ToInteger<T>().Value(out);
+  }
+
+  /// \brief Convert to a floating-point number (scaled)
+  float ToFloat(int32_t scale) const;
+  /// \brief Convert to a floating-point number (scaled)
+  double ToDouble(int32_t scale) const;
+
+  /// \brief Convert to a floating-point number (scaled)
+  template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
+  T ToReal(int32_t scale) const {
+    static_assert(std::is_same_v<T, float> || std::is_same_v<T, double>,
+                  "Unexpected floating-point type");
+    if constexpr (std::is_same_v<T, float>) {
+      return ToFloat(scale);
+    } else {
+      return ToDouble(scale);
+    }
+  }
+
+  ARROW_FRIEND_EXPORT friend std::ostream& operator<<(std::ostream& os,
+                                                      const Decimal32& decimal);
+
+ private:
+  /// Converts internal error code to Status
+  Status ToArrowStatus(DecimalStatus dstatus) const;
+};
+
+class ARROW_EXPORT Decimal64 : public BasicDecimal64 {
+ public:
+  /// \cond FALSE
+  // (need to avoid a duplicate definition in sphinx)
+  using BasicDecimal64::BasicDecimal64;
+  /// \endcond
+
+  /// \brief constructor creates a Decimal64 from a BasicDecimal64
+  constexpr Decimal64(const BasicDecimal64& value) noexcept  // NOLINT runtime/explicit
+      : BasicDecimal64(value) {}
+
+  explicit Decimal64(const BasicDecimal32& value) noexcept
+      : BasicDecimal64(static_cast<int64_t>(value.value())) {}
+
+  /// \brief Parse the number from a base 10 string representation
+  explicit Decimal64(const std::string& value);
+
+  /// \brief Empty constructor creates a Decimal64 with a value of 0
+  /// this is required for some older compilers
+  constexpr Decimal64() noexcept : BasicDecimal64() {}
+
+  /// \brief Divide this number by right and return the result.
+  ///
+  /// This operation is not destructive.
+  /// The answer rounds to zero. Signs work like:
+  ///   21 /  5 ->  4,  1
+  ///  -21 /  5 -> -4, -1
+  ///   21 / -5 -> -4,  1
+  ///  -21 / -5 ->  4, -1
+  /// \param[in] divisor the number to divide by
+  /// \return the pair of the quotient and the remainder
+  Result<std::pair<Decimal64, Decimal64>> Divide(const Decimal64& divisor) const {
+    std::pair<Decimal64, Decimal64> result;
+    auto dstatus = BasicDecimal64::Divide(divisor, &result.first, &result.second);
+    ARROW_RETURN_NOT_OK(ToArrowStatus(dstatus));
+    return result;
+  }
+
+  /// \brief Convert the Decimal64 value to a base 10 decimal string with the given scale
+  std::string ToString(int32_t scale) const;
+
+  /// \brief Convert the value to an integer string
+  std::string ToIntegerString() const;
+
+  /// \brief Cast this value to an int64_t
+  explicit operator int64_t() const;
+
+  /// \brief Convert a decimal string to a Decimal value, optionally including
+  /// precision and scale if they're passed in and not null.
+  static Status FromString(std::string_view s, Decimal64* out, int32_t* precision,
+                           int32_t* scale = NULLPTR);
+  static Status FromString(const std::string& s, Decimal64* out, int32_t* precision,
+                           int32_t* scale = NULLPTR);
+  static Status FromString(const char* s, Decimal64* out, int32_t* precision,
+                           int32_t* scale = NULLPTR);
+  static Result<Decimal64> FromString(std::string_view s);
+  static Result<Decimal64> FromString(const std::string& s);
+  static Result<Decimal64> FromString(const char* s);
+
+  static Result<Decimal64> FromReal(double real, int32_t precision, int32_t scale);
+  static Result<Decimal64> FromReal(float real, int32_t precision, int32_t scale);
+
+  /// \brief Convert from a big-endian byte representation. The length must be
+  ///        between 1 and 4
+  /// \return error statis if the length is an invalid value
+  static Result<Decimal64> FromBigEndian(const uint8_t* data, int32_t length);
+
+  /// \brief Convert Decimal64 from one scale to another
+  Result<Decimal64> Rescale(int32_t original_scale, int32_t new_scale) const {
+    Decimal64 out;
+    auto dstatus = BasicDecimal64::Rescale(original_scale, new_scale, &out);
+    ARROW_RETURN_NOT_OK(ToArrowStatus(dstatus));
+    return out;
+  }
+
+  /// \brief Convert to a signed integer
+  template <typename T, typename = internal::EnableIfIsOneOf<T, int32_t, int64_t>>
+  Result<T> ToInteger() const {
+    return static_cast<T>(value_);
+  }
+
+  /// \brief Convert to a signed integer
+  template <typename T, typename = internal::EnableIfIsOneOf<T, int32_t, int64_t>>
+  Status ToInteger(T* out) const {
+    return ToInteger<T>().Value(out);
+  }
+
+  /// \brief Convert to a floating-point number (scaled)
+  float ToFloat(int32_t scale) const;
+  /// \brief Convert to a floating-point number (scaled)
+  double ToDouble(int32_t scale) const;
+
+  /// \brief Convert to a floating-point number (scaled)
+  template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
+  T ToReal(int32_t scale) const {
+    static_assert(std::is_same_v<T, float> || std::is_same_v<T, double>,
+                  "Unexpected floating-point type");
+    if constexpr (std::is_same_v<T, float>) {
+      return ToFloat(scale);
+    } else {
+      return ToDouble(scale);
+    }
+  }
+
+  ARROW_FRIEND_EXPORT friend std::ostream& operator<<(std::ostream& os,
+                                                      const Decimal64& decimal);
+
+ private:
+  /// Converts internal error code to Status
+  Status ToArrowStatus(DecimalStatus dstatus) const;
+};
+
 /// Represents a signed 128-bit integer in two's complement.
 /// Calculations wrap around and overflow is ignored.
 /// The max decimal precision that can be safely represented is
diff --git a/cpp/src/arrow/util/decimal_internal.h b/cpp/src/arrow/util/decimal_internal.h
index b3a8b1127f918..3845a544cff31 100644
--- a/cpp/src/arrow/util/decimal_internal.h
+++ b/cpp/src/arrow/util/decimal_internal.h
@@ -30,9 +30,26 @@
 
 namespace arrow {
 
+constexpr auto kInt32DecimalDigits =
+    static_cast<size_t>(std::numeric_limits<int32_t>::digits10);
+
 constexpr auto kInt64DecimalDigits =
     static_cast<size_t>(std::numeric_limits<int64_t>::digits10);
 
+constexpr uint32_t kUInt32PowersOfTen[kInt32DecimalDigits + 1] = {
+    // clang-format off
+  1ULL,
+  10ULL,
+  100ULL,
+  1000ULL,
+  10000ULL,
+  100000ULL,
+  1000000ULL,
+  10000000ULL,
+  100000000ULL,
+    // clang-format on
+};
+
 constexpr uint64_t kUInt64PowersOfTen[kInt64DecimalDigits + 1] = {
     // clang-format off
     1ULL,
@@ -106,6 +123,60 @@ constexpr double kDoublePowersOfTen[2 * kPrecomputedPowersOfTen + 1] = {
     1e56,  1e57,  1e58,  1e59,  1e60,  1e61,  1e62,  1e63,  1e64,  1e65,  1e66,  1e67,
     1e68,  1e69,  1e70,  1e71,  1e72,  1e73,  1e74,  1e75,  1e76};
 
+constexpr BasicDecimal32 kDecimal32PowersOfTen[9 + 1] = {
+    BasicDecimal32(1),         BasicDecimal32(10),       BasicDecimal32(100),
+    BasicDecimal32(1000),      BasicDecimal32(10000),    BasicDecimal32(100000),
+    BasicDecimal32(1000000),   BasicDecimal32(10000000), BasicDecimal32(100000000),
+    BasicDecimal32(1000000000)};
+
+constexpr BasicDecimal32 kDecimal32HalfPowersOfTen[] = {
+    BasicDecimal32(0),        BasicDecimal32(5),       BasicDecimal32(50),
+    BasicDecimal32(500),      BasicDecimal32(5000),    BasicDecimal32(50000),
+    BasicDecimal32(500000),   BasicDecimal32(5000000), BasicDecimal32(50000000),
+    BasicDecimal32(500000000)};
+
+constexpr BasicDecimal64 kDecimal64PowersOfTen[18 + 1] = {
+    BasicDecimal64(1),
+    BasicDecimal64(10),
+    BasicDecimal64(100),
+    BasicDecimal64(1000),
+    BasicDecimal64(10000),
+    BasicDecimal64(100000),
+    BasicDecimal64(1000000),
+    BasicDecimal64(10000000),
+    BasicDecimal64(100000000),
+    BasicDecimal64(1000000000),
+    BasicDecimal64(10000000000),
+    BasicDecimal64(100000000000),
+    BasicDecimal64(1000000000000),
+    BasicDecimal64(10000000000000),
+    BasicDecimal64(100000000000000),
+    BasicDecimal64(1000000000000000),
+    BasicDecimal64(10000000000000000),
+    BasicDecimal64(100000000000000000),
+    BasicDecimal64(1000000000000000000)};
+
+constexpr BasicDecimal64 kDecimal64HalfPowersOfTen[18 + 1] = {
+    BasicDecimal64(0),
+    BasicDecimal64(5),
+    BasicDecimal64(50),
+    BasicDecimal64(500),
+    BasicDecimal64(5000),
+    BasicDecimal64(50000),
+    BasicDecimal64(500000),
+    BasicDecimal64(5000000),
+    BasicDecimal64(50000000),
+    BasicDecimal64(500000000),
+    BasicDecimal64(5000000000),
+    BasicDecimal64(50000000000),
+    BasicDecimal64(500000000000),
+    BasicDecimal64(5000000000000),
+    BasicDecimal64(50000000000000),
+    BasicDecimal64(500000000000000),
+    BasicDecimal64(5000000000000000),
+    BasicDecimal64(50000000000000000),
+    BasicDecimal64(500000000000000000)};
+
 constexpr BasicDecimal128 kDecimal128PowersOfTen[38 + 1] = {
     BasicDecimal128(1LL),
     BasicDecimal128(10LL),
@@ -420,6 +491,9 @@ constexpr BasicDecimal256 kDecimal256HalfPowersOfTen[] = {
     BasicDecimal256FromLE(0ULL, 13527356396454709248ULL, 9489746690038731964ULL,
                           796545955566226138ULL)};
 
+static constexpr BasicDecimal256 kMaxDecimal256Value = BasicDecimal256FromLE(
+    0ULL, 10084168908774762496ULL, 12965995782233477362ULL, 159309191113245227ULL);
+
 #undef BasicDecimal256FromLE
 
 // ceil(log2(10 ^ k)) for k in [0...76]
@@ -466,6 +540,32 @@ struct RealTraits<double> {
 template <typename DecimalType>
 struct DecimalTraits {};
 
+template <>
+struct DecimalTraits<BasicDecimal32> {
+  static constexpr const BasicDecimal32* powers_of_ten() { return kDecimal32PowersOfTen; }
+
+  static constexpr const BasicDecimal32* half_powers_of_ten() {
+    return kDecimal32HalfPowersOfTen;
+  }
+
+  static constexpr int kMaxPrecision = BasicDecimal32::kMaxPrecision;
+  static constexpr BasicDecimal32 kMaxValue = BasicDecimal32(999999999);
+  static constexpr const char* kTypeName = "Decimal32";
+};
+
+template <>
+struct DecimalTraits<BasicDecimal64> {
+  static constexpr const BasicDecimal64* powers_of_ten() { return kDecimal64PowersOfTen; }
+
+  static constexpr const BasicDecimal64* half_powers_of_ten() {
+    return kDecimal64HalfPowersOfTen;
+  }
+
+  static constexpr int kMaxPrecision = BasicDecimal64::kMaxPrecision;
+  static constexpr BasicDecimal64 kMaxValue = BasicDecimal64(999999999999999999);
+  static constexpr const char* kTypeName = "Decimal64";
+};
+
 template <>
 struct DecimalTraits<BasicDecimal128> {
   static constexpr const BasicDecimal128* powers_of_ten() {
@@ -486,6 +586,10 @@ struct DecimalTraits<BasicDecimal256> {
   static constexpr const char* kTypeName = "Decimal256";
 };
 
+template <>
+struct DecimalTraits<Decimal32> : public DecimalTraits<BasicDecimal32> {};
+template <>
+struct DecimalTraits<Decimal64> : public DecimalTraits<BasicDecimal64> {};
 template <>
 struct DecimalTraits<Decimal128> : public DecimalTraits<BasicDecimal128> {};
 template <>
diff --git a/cpp/src/arrow/util/decimal_test.cc b/cpp/src/arrow/util/decimal_test.cc
index 0a8b7a09730bf..0cb8b2878f1b6 100644
--- a/cpp/src/arrow/util/decimal_test.cc
+++ b/cpp/src/arrow/util/decimal_test.cc
@@ -48,7 +48,7 @@ using internal::checked_cast;
 using internal::int128_t;
 using internal::uint128_t;
 
-using DecimalTypes = ::testing::Types<Decimal128, Decimal256>;
+using DecimalTypes = ::testing::Types<Decimal32, Decimal64, Decimal128, Decimal256>;
 
 static const int128_t kInt128Max =
     (static_cast<int128_t>(INT64_MAX) << 64) + static_cast<int128_t>(UINT64_MAX);
@@ -95,6 +95,16 @@ Decimal128 Decimal128FromInt128(int128_t value) {
 template <typename DecimalType>
 struct DecimalTraits {};
 
+template <>
+struct DecimalTraits<Decimal32> {
+  using ArrowType = Decimal32Type;
+};
+
+template <>
+struct DecimalTraits<Decimal64> {
+  using ArrowType = Decimal64Type;
+};
+
 template <>
 struct DecimalTraits<Decimal128> {
   using ArrowType = Decimal128Type;
@@ -115,8 +125,10 @@ class DecimalFromStringTest : public ::testing::Test {
 
   void TestStringStartingWithPlus() {
     AssertDecimalFromString("+234.567", DecimalType(234567), 6, 3);
-    AssertDecimalFromString("+2342394230592.232349023094",
-                            DecimalType("2342394230592232349023094"), 25, 12);
+    if constexpr (DecimalType::kMaxPrecision >= 25) {
+      AssertDecimalFromString("+2342394230592.232349023094",
+                              DecimalType("2342394230592232349023094"), 25, 12);
+    }
   }
 
   void TestInvalidInput() {
@@ -125,7 +137,7 @@ class DecimalFromStringTest : public ::testing::Test {
           "00a", "1e1a", "0.00123D/3", "1.23eA8", "1.23E+3A", "-1.23E--5",
           "1.2345E+++07"}) {
       ARROW_SCOPED_TRACE("invalid_value = '", invalid_value, "'");
-      ASSERT_RAISES(Invalid, Decimal128::FromString(invalid_value));
+      ASSERT_RAISES(Invalid, DecimalType::FromString(invalid_value));
     }
   }
 
@@ -582,17 +594,21 @@ class DecimalFromIntegerTest : public ::testing::Test {
   }
 
   void TestConstructibleFromAnyIntegerType() {
-    CheckConstructFrom<char>();                // NOLINT
-    CheckConstructFrom<signed char>();         // NOLINT
-    CheckConstructFrom<unsigned char>();       // NOLINT
-    CheckConstructFrom<short>();               // NOLINT
-    CheckConstructFrom<unsigned short>();      // NOLINT
-    CheckConstructFrom<int>();                 // NOLINT
-    CheckConstructFrom<unsigned int>();        // NOLINT
-    CheckConstructFrom<long>();                // NOLINT
-    CheckConstructFrom<unsigned long>();       // NOLINT
-    CheckConstructFrom<long long>();           // NOLINT
-    CheckConstructFrom<unsigned long long>();  // NOLINT
+    CheckConstructFrom<char>();            // NOLINT
+    CheckConstructFrom<signed char>();     // NOLINT
+    CheckConstructFrom<unsigned char>();   // NOLINT
+    CheckConstructFrom<short>();           // NOLINT
+    CheckConstructFrom<unsigned short>();  // NOLINT
+    CheckConstructFrom<int>();             // NOLINT
+    CheckConstructFrom<unsigned int>();    // NOLINT
+    if constexpr (DecimalType::kMaxPrecision > 9) {
+      CheckConstructFrom<long>();           // NOLINT
+      CheckConstructFrom<unsigned long>();  // NOLINT
+    }
+    if constexpr (DecimalType::kMaxPrecision > 18) {
+      CheckConstructFrom<long long>();           // NOLINT
+      CheckConstructFrom<unsigned long long>();  // NOLINT
+    }
   }
 
   void TestConstructibleFromBool() {
@@ -611,21 +627,26 @@ class DecimalFromIntegerTest : public ::testing::Test {
     TestNumericLimit<UInt8Type>();
     TestNumericLimit<Int16Type>();
     TestNumericLimit<UInt16Type>();
-    TestNumericLimit<Int32Type>();
-    TestNumericLimit<UInt32Type>();
-    TestNumericLimit<Int64Type>();
-    TestNumericLimit<UInt64Type>();
+    if constexpr (DecimalType::kMaxPrecision > 9) {
+      TestNumericLimit<Int32Type>();
+      TestNumericLimit<UInt32Type>();
+    }
+    if constexpr (DecimalType::kMaxPrecision > 18) {
+      TestNumericLimit<Int64Type>();
+      TestNumericLimit<UInt64Type>();
+    }
   }
 
   template <typename ArrowType>
   void TestNumericLimit() {
     using c_type = typename ArrowType::c_type;
-    ASSERT_OK_AND_ASSIGN(const int32_t precision,
+    ASSERT_OK_AND_ASSIGN(int32_t precision,
                          MaxDecimalDigitsForInteger(ArrowType::type_id));
+
     DecimalType min_value(std::numeric_limits<c_type>::min());
-    ASSERT_TRUE(min_value.FitsInPrecision(precision));
+    ASSERT_TRUE(min_value.FitsInPrecision(precision)) << "precision " << precision;
     DecimalType max_value(std::numeric_limits<c_type>::max());
-    ASSERT_TRUE(max_value.FitsInPrecision(precision));
+    ASSERT_TRUE(max_value.FitsInPrecision(precision)) << "precision " << precision;
   }
 };
 
@@ -832,15 +853,17 @@ class TestDecimalFromReal : public ::testing::Test {
         // clang-format on
     };
     for (const ParamType& param : params) {
-      CheckDecimalFromReal<Decimal>(param.real, param.precision, param.scale,
-                                    param.expected);
+      if (Decimal::kMaxPrecision > param.precision) {
+        CheckDecimalFromReal<Decimal>(param.real, param.precision, param.scale,
+                                      param.expected);
+      }
     }
   }
 
   void TestErrors() {
-    ASSERT_RAISES(Invalid, Decimal::FromReal(INFINITY, 19, 4));
-    ASSERT_RAISES(Invalid, Decimal::FromReal(-INFINITY, 19, 4));
-    ASSERT_RAISES(Invalid, Decimal::FromReal(NAN, 19, 4));
+    ASSERT_RAISES(Invalid, Decimal::FromReal(INFINITY, Decimal::kMaxPrecision / 2, 4));
+    ASSERT_RAISES(Invalid, Decimal::FromReal(-INFINITY, Decimal::kMaxPrecision / 2, 4));
+    ASSERT_RAISES(Invalid, Decimal::FromReal(NAN, Decimal::kMaxPrecision / 2, 4));
     // Overflows
     ASSERT_RAISES(Invalid, Decimal::FromReal(1000.0, 3, 0));
     ASSERT_RAISES(Invalid, Decimal::FromReal(-1000.0, 3, 0));
@@ -848,13 +871,17 @@ class TestDecimalFromReal : public ::testing::Test {
     ASSERT_RAISES(Invalid, Decimal::FromReal(-1000.0, 5, 2));
     ASSERT_RAISES(Invalid, Decimal::FromReal(999.996, 5, 2));
     ASSERT_RAISES(Invalid, Decimal::FromReal(-999.996, 5, 2));
-    ASSERT_RAISES(Invalid, Decimal::FromReal(1e+36, 36, 0));
-    ASSERT_RAISES(Invalid, Decimal::FromReal(-1e+36, 36, 0));
+    if constexpr (Decimal::kMaxPrecision >= 36) {
+      ASSERT_RAISES(Invalid, Decimal::FromReal(1e+36, 36, 0));
+      ASSERT_RAISES(Invalid, Decimal::FromReal(-1e+36, 36, 0));
+    }
   }
 };
 
 using RealTypes =
-    ::testing::Types<std::pair<Decimal128, float>, std::pair<Decimal128, double>,
+    ::testing::Types<std::pair<Decimal32, float>, std::pair<Decimal32, double>,
+                     std::pair<Decimal64, float>, std::pair<Decimal64, double>,
+                     std::pair<Decimal128, float>, std::pair<Decimal128, double>,
                      std::pair<Decimal256, float>, std::pair<Decimal256, double>>;
 TYPED_TEST_SUITE(TestDecimalFromReal, RealTypes);
 
@@ -880,7 +907,7 @@ class TestDecimalFromRealFloat : public ::testing::Test {
         FromFloatTestParam{16383.999f, 19, 3, "16383.999"},
         // 1 - 2**-24
         FromFloatTestParam{0.99999994f, 10, 10, "0.9999999404"},
-        FromFloatTestParam{0.99999994f, 16, 16, "0.9999999403953552"},
+        FromFloatTestParam{0.99999994f, 15, 15, "0.999999940395355"},
         FromFloatTestParam{0.99999994f, 20, 20, "0.99999994039535522461"},
         FromFloatTestParam{0.99999994f, 21, 21, "0.999999940395355224609"},
         FromFloatTestParam{0.99999994f, 38, 38,
@@ -896,22 +923,30 @@ TYPED_TEST_SUITE(TestDecimalFromRealFloat, DecimalTypes);
 
 TYPED_TEST(TestDecimalFromRealFloat, SuccessConversion) {
   for (const auto& param : this->GetValues()) {
-    CheckDecimalFromReal<TypeParam>(param.real, param.precision, param.scale,
-                                    param.expected);
+    if (TypeParam::kMaxPrecision > param.precision) {
+      CheckDecimalFromReal<TypeParam>(param.real, param.precision, param.scale,
+                                      param.expected);
+    }
   }
 }
 
 TYPED_TEST(TestDecimalFromRealFloat, LargeValues) {
+  constexpr auto kMaxScale = TypeParam::kMaxScale;
   // Test the entire float range
   for (int32_t scale = -38; scale <= 38; ++scale) {
-    float real = std::pow(10.0f, static_cast<float>(scale));
-    CheckDecimalFromRealIntegerString<TypeParam>(real, 1, -scale, "1");
+    if (TypeParam::kMaxScale >= std::abs(scale)) {
+      float real = std::pow(10.0f, static_cast<float>(scale));
+      CheckDecimalFromRealIntegerString<TypeParam>(real, 1, -scale, "1");
+    }
   }
+
   for (int32_t scale = -37; scale <= 36; ++scale) {
-    float real = 123.f * std::pow(10.f, static_cast<float>(scale));
-    CheckDecimalFromRealIntegerString<TypeParam>(real, 2, -scale - 1, "12");
-    CheckDecimalFromRealIntegerString<TypeParam>(real, 3, -scale, "123");
-    CheckDecimalFromRealIntegerString<TypeParam>(real, 4, -scale + 1, "1230");
+    if (scale >= (-kMaxScale + 1) && scale <= (kMaxScale - 2)) {
+      float real = 123.f * std::pow(10.f, static_cast<float>(scale));
+      CheckDecimalFromRealIntegerString<TypeParam>(real, 2, -scale - 1, "12");
+      CheckDecimalFromRealIntegerString<TypeParam>(real, 3, -scale, "123");
+      CheckDecimalFromRealIntegerString<TypeParam>(real, 4, -scale + 1, "1230");
+    }
   }
 }
 
@@ -976,7 +1011,7 @@ class TestDecimalFromRealDouble : public ::testing::Test {
         FromDoubleTestParam{0.9999999999999998, 16, 16, "0.9999999999999998"},
       };
       // clang-format on
-    } else {
+    } else if (std::is_same_v<T, Decimal256>) {
       // clang-format off
       type_dependent_values = {
         // 1 - 2**-52
@@ -1012,24 +1047,31 @@ TYPED_TEST_SUITE(TestDecimalFromRealDouble, DecimalTypes);
 
 TYPED_TEST(TestDecimalFromRealDouble, SuccessConversion) {
   for (const auto& param : this->GetValues()) {
-    CheckDecimalFromReal<TypeParam>(param.real, param.precision, param.scale,
-                                    param.expected);
+    if (TypeParam::kMaxPrecision >= param.precision) {
+      CheckDecimalFromReal<TypeParam>(param.real, param.precision, param.scale,
+                                      param.expected);
+    }
   }
 }
 
 TYPED_TEST(TestDecimalFromRealDouble, LargeValues) {
   constexpr auto kMaxScale = TypeParam::kMaxScale;
   for (int32_t scale = -kMaxScale; scale <= kMaxScale; ++scale) {
-    double real = std::pow(10.0, static_cast<double>(scale));
-    ARROW_SCOPED_TRACE("scale = ", scale, ", real = ", real);
-    CheckDecimalFromRealIntegerString<TypeParam>(real, 1, -scale, "1");
+    if (std::abs(1 - scale) < kMaxScale) {
+      double real = std::pow(10.0, static_cast<double>(scale));
+      ARROW_SCOPED_TRACE("scale = ", scale, ", real = ", real);
+      CheckDecimalFromRealIntegerString<TypeParam>(real, 1, -scale, "1");
+    }
   }
+
   for (int32_t scale = -kMaxScale + 1; scale <= kMaxScale - 1; ++scale) {
-    double real = 123. * std::pow(10.0, static_cast<double>(scale));
-    ARROW_SCOPED_TRACE("scale = ", scale, ", real = ", real);
-    CheckDecimalFromRealIntegerString<TypeParam>(real, 2, -scale - 1, "12");
-    CheckDecimalFromRealIntegerString<TypeParam>(real, 3, -scale, "123");
-    CheckDecimalFromRealIntegerString<TypeParam>(real, 4, -scale + 1, "1230");
+    if (std::abs(4 - scale) < kMaxScale) {
+      double real = 123. * std::pow(10.0, static_cast<double>(scale));
+      ARROW_SCOPED_TRACE("scale = ", scale, ", real = ", real);
+      CheckDecimalFromRealIntegerString<TypeParam>(real, 2, -scale - 1, "12");
+      CheckDecimalFromRealIntegerString<TypeParam>(real, 3, -scale, "123");
+      CheckDecimalFromRealIntegerString<TypeParam>(real, 4, -scale + 1, "1230");
+    }
   }
 }
 
@@ -1130,10 +1172,14 @@ class TestDecimalToReal : public ::testing::Test {
         // clang-format on
     };
     for (const ParamType& param : params) {
-      CheckDecimalToReal<Decimal, Real>(param.decimal_value, param.scale, param.expected);
-      if (param.decimal_value != "0") {
-        CheckDecimalToReal<Decimal, Real>("-" + param.decimal_value, param.scale,
-                                          -param.expected);
+      if (param.decimal_value.size() < Decimal::kMaxPrecision &&
+          std::abs(param.scale) < Decimal::kMaxScale) {
+        CheckDecimalToReal<Decimal, Real>(param.decimal_value, param.scale,
+                                          param.expected);
+        if (param.decimal_value != "0") {
+          CheckDecimalToReal<Decimal, Real>("-" + param.decimal_value, param.scale,
+                                            -param.expected);
+        }
       }
     }
   }
@@ -1170,13 +1216,15 @@ TYPED_TEST(TestDecimalToRealFloat, LargeValues) {
 }
 
 TYPED_TEST(TestDecimalToRealFloat, Precision) {
-  // 2**63 + 2**40 (exactly representable in a float's 24 bits of precision)
-  CheckDecimalToReal<TypeParam, float>("9223373136366403584", 0, 9.223373e+18f);
-  CheckDecimalToReal<TypeParam, float>("-9223373136366403584", 0, -9.223373e+18f);
-  // 2**64 + 2**41 (exactly representable in a float)
-  CheckDecimalToReal<TypeParam, float>("18446746272732807168", 0, 1.8446746e+19f);
-  CheckDecimalToReal<TypeParam, float>("-18446746272732807168", 0, -1.8446746e+19f);
+  if constexpr (TypeParam::kMaxPrecision >= 19) {
+    // 2**63 + 2**40 (exactly representable in a float's 24 bits of precision)
+    CheckDecimalToReal<TypeParam, float>("9223373136366403584", 0, 9.223373e+18f);
+    CheckDecimalToReal<TypeParam, float>("-9223373136366403584", 0, -9.223373e+18f);
 
+    // 2**64 + 2**41 (exactly representable in a float)
+    CheckDecimalToReal<TypeParam, float>("18446746272732807168", 0, 1.8446746e+19f);
+    CheckDecimalToReal<TypeParam, float>("-18446746272732807168", 0, -1.8446746e+19f);
+  }
   // Integers are always exact
   auto scale = TypeParam::kMaxScale - 1;
   std::string seven = "7.";
@@ -1184,26 +1232,33 @@ TYPED_TEST(TestDecimalToRealFloat, Precision) {
   CheckDecimalToReal<TypeParam, float>(seven, scale, 7.0f);
   CheckDecimalToReal<TypeParam, float>("-" + seven, scale, -7.0f);
 
-  CheckDecimalToReal<TypeParam, float>("99999999999999999999.0000000000000000", 16,
-                                       99999999999999999999.0f);
-  CheckDecimalToReal<TypeParam, float>("-99999999999999999999.0000000000000000", 16,
-                                       -99999999999999999999.0f);
+  if constexpr (TypeParam::kMaxPrecision >= 20) {
+    CheckDecimalToReal<TypeParam, float>("99999999999999999999.0000000000000000", 16,
+                                         99999999999999999999.0f);
+    CheckDecimalToReal<TypeParam, float>("-99999999999999999999.0000000000000000", 16,
+                                         -99999999999999999999.0f);
+  }
 
   // Small fractions are within one ULP
   CheckDecimalToRealWithinOneULP<TypeParam, float>("9999999.9", 1, 9999999.9f);
   CheckDecimalToRealWithinOneULP<TypeParam, float>("-9999999.9", 1, -9999999.9f);
-  CheckDecimalToRealWithinOneULP<TypeParam, float>("9999999.999999", 6, 9999999.999999f);
-  CheckDecimalToRealWithinOneULP<TypeParam, float>("-9999999.999999", 6,
-                                                   -9999999.999999f);
+  if constexpr (TypeParam::kMaxPrecision >= 13) {
+    CheckDecimalToRealWithinOneULP<TypeParam, float>("9999999.999999", 6,
+                                                     9999999.999999f);
+    CheckDecimalToRealWithinOneULP<TypeParam, float>("-9999999.999999", 6,
+                                                     -9999999.999999f);
+  }
 
-  // Large fractions are within 2^-23
-  constexpr float epsilon = 1.1920928955078125e-07f;  // 2^-23
-  CheckDecimalToRealWithinEpsilon<TypeParam, float>(
-      "112334829348925.99070703983306884765625", 23, epsilon,
-      112334829348925.99070703983306884765625f);
-  CheckDecimalToRealWithinEpsilon<TypeParam, float>(
-      "1.987748987892758765582589910934859345", 36, epsilon,
-      1.987748987892758765582589910934859345f);
+  if constexpr (TypeParam::kMaxScale >= 23) {
+    // Large fractions are within 2^-23
+    constexpr float epsilon = 1.1920928955078125e-07f;  // 2^-23
+    CheckDecimalToRealWithinEpsilon<TypeParam, float>(
+        "112334829348925.99070703983306884765625", 23, epsilon,
+        112334829348925.99070703983306884765625f);
+    CheckDecimalToRealWithinEpsilon<TypeParam, float>(
+        "1.987748987892758765582589910934859345", 36, epsilon,
+        1.987748987892758765582589910934859345f);
+  }
 }
 
 // ToReal<double> tests are disabled on MinGW because of precision issues in results
@@ -1230,65 +1285,78 @@ TYPED_TEST(TestDecimalToRealDouble, LargeValues) {
 }
 
 TYPED_TEST(TestDecimalToRealDouble, Precision) {
-  // 2**63 + 2**11 (exactly representable in a double's 53 bits of precision)
-  CheckDecimalToReal<TypeParam, double>("9223372036854777856", 0, 9.223372036854778e+18);
-  CheckDecimalToReal<TypeParam, double>("-9223372036854777856", 0,
-                                        -9.223372036854778e+18);
-  // 2**64 - 2**11 (exactly representable in a double)
-  CheckDecimalToReal<TypeParam, double>("18446744073709549568", 0, 1.844674407370955e+19);
-  CheckDecimalToReal<TypeParam, double>("-18446744073709549568", 0,
-                                        -1.844674407370955e+19);
-  // 2**64 + 2**11 (exactly representable in a double)
-  CheckDecimalToReal<TypeParam, double>("18446744073709555712", 0,
-                                        1.8446744073709556e+19);
-  CheckDecimalToReal<TypeParam, double>("-18446744073709555712", 0,
-                                        -1.8446744073709556e+19);
-  // Almost 10**38 (minus 2**73)
-  CheckDecimalToReal<TypeParam, double>("99999999999999978859343891977453174784", 0,
-                                        9.999999999999998e+37);
-  CheckDecimalToReal<TypeParam, double>("-99999999999999978859343891977453174784", 0,
-                                        -9.999999999999998e+37);
-  CheckDecimalToReal<TypeParam, double>("99999999999999978859343891977453174784", 10,
-                                        9.999999999999998e+27);
-  CheckDecimalToReal<TypeParam, double>("-99999999999999978859343891977453174784", 10,
-                                        -9.999999999999998e+27);
-  CheckDecimalToReal<TypeParam, double>("99999999999999978859343891977453174784", -10,
-                                        9.999999999999998e+47);
-  CheckDecimalToReal<TypeParam, double>("-99999999999999978859343891977453174784", -10,
-                                        -9.999999999999998e+47);
+  if constexpr (TypeParam::kMaxPrecision >= 19) {
+    // 2**63 + 2**11 (exactly representable in a double's 53 bits of precision)
+    CheckDecimalToReal<TypeParam, double>("9223372036854777856", 0,
+                                          9.223372036854778e+18);
+    CheckDecimalToReal<TypeParam, double>("-9223372036854777856", 0,
+                                          -9.223372036854778e+18);
+    // 2**64 - 2**11 (exactly representable in a double)
+    CheckDecimalToReal<TypeParam, double>("18446744073709549568", 0,
+                                          1.844674407370955e+19);
+    CheckDecimalToReal<TypeParam, double>("-18446744073709549568", 0,
+                                          -1.844674407370955e+19);
+    // 2**64 + 2**11 (exactly representable in a double)
+    CheckDecimalToReal<TypeParam, double>("18446744073709555712", 0,
+                                          1.8446744073709556e+19);
+    CheckDecimalToReal<TypeParam, double>("-18446744073709555712", 0,
+                                          -1.8446744073709556e+19);
+
+    // Almost 10**38 (minus 2**73)
+    CheckDecimalToReal<TypeParam, double>("99999999999999978859343891977453174784", 0,
+                                          9.999999999999998e+37);
+    CheckDecimalToReal<TypeParam, double>("-99999999999999978859343891977453174784", 0,
+                                          -9.999999999999998e+37);
+    CheckDecimalToReal<TypeParam, double>("99999999999999978859343891977453174784", 10,
+                                          9.999999999999998e+27);
+    CheckDecimalToReal<TypeParam, double>("-99999999999999978859343891977453174784", 10,
+                                          -9.999999999999998e+27);
+    CheckDecimalToReal<TypeParam, double>("99999999999999978859343891977453174784", -10,
+                                          9.999999999999998e+47);
+    CheckDecimalToReal<TypeParam, double>("-99999999999999978859343891977453174784", -10,
+                                          -9.999999999999998e+47);
+  }
   // Integers are always exact
   auto scale = TypeParam::kMaxScale - 1;
   std::string seven = "7.";
   seven.append(scale, '0');
   CheckDecimalToReal<TypeParam, double>(seven, scale, 7.0);
   CheckDecimalToReal<TypeParam, double>("-" + seven, scale, -7.0);
-
-  CheckDecimalToReal<TypeParam, double>("99999999999999999999.0000000000000000", 16,
-                                        99999999999999999999.0);
-  CheckDecimalToReal<TypeParam, double>("-99999999999999999999.0000000000000000", 16,
-                                        -99999999999999999999.0);
+  if constexpr (TypeParam::kMaxPrecision >= 20) {
+    CheckDecimalToReal<TypeParam, double>("99999999999999999999.0000000000000000", 16,
+                                          99999999999999999999.0);
+    CheckDecimalToReal<TypeParam, double>("-99999999999999999999.0000000000000000", 16,
+                                          -99999999999999999999.0);
+  }
 
   // Small fractions are within one ULP
   CheckDecimalToRealWithinOneULP<TypeParam, double>("9999999.9", 1, 9999999.9);
   CheckDecimalToRealWithinOneULP<TypeParam, double>("-9999999.9", 1, -9999999.9);
-  CheckDecimalToRealWithinOneULP<TypeParam, double>("9999999.999999999999999", 15,
-                                                    9999999.999999999999999);
-  CheckDecimalToRealWithinOneULP<TypeParam, double>("-9999999.999999999999999", 15,
-                                                    -9999999.999999999999999);
-
-  // Large fractions are within 2^-52
-  constexpr double epsilon = 2.220446049250313080847263336181640625e-16;  // 2^-52
-  CheckDecimalToRealWithinEpsilon<TypeParam, double>(
-      "112334829348925.99070703983306884765625", 23, epsilon,
-      112334829348925.99070703983306884765625);
-  CheckDecimalToRealWithinEpsilon<TypeParam, double>(
-      "1.987748987892758765582589910934859345", 36, epsilon,
-      1.987748987892758765582589910934859345);
+  if constexpr (TypeParam::kMaxPrecision >= 23) {
+    CheckDecimalToRealWithinOneULP<TypeParam, double>("9999999.999999999999999", 15,
+                                                      9999999.999999999999999);
+    CheckDecimalToRealWithinOneULP<TypeParam, double>("-9999999.999999999999999", 15,
+                                                      -9999999.999999999999999);
+    // Large fractions are within 2^-52
+    constexpr double epsilon = 2.220446049250313080847263336181640625e-16;  // 2^-52
+    CheckDecimalToRealWithinEpsilon<TypeParam, double>(
+        "112334829348925.99070703983306884765625", 23, epsilon,
+        112334829348925.99070703983306884765625);
+    CheckDecimalToRealWithinEpsilon<TypeParam, double>(
+        "1.987748987892758765582589910934859345", 36, epsilon,
+        1.987748987892758765582589910934859345);
+  }
 }
 
 #endif  // __MINGW32__
 
-TEST(Decimal128Test, TestFromBigEndian) {
+template <typename DecimalType>
+class TestBasicDecimalFunctionality : public ::testing::Test {};
+// Decimal256 tests don't fit the same mold as the others for easy generic tests
+using BasicFunctionalityDecimalTypes = ::testing::Types<Decimal32, Decimal64, Decimal128>;
+TYPED_TEST_SUITE(TestBasicDecimalFunctionality, BasicFunctionalityDecimalTypes);
+
+TYPED_TEST(TestBasicDecimalFunctionality, TestFromBigEndian) {
   // We test out a variety of scenarios:
   //
   // * Positive values that are left shifted
@@ -1302,11 +1370,13 @@ TEST(Decimal128Test, TestFromBigEndian) {
   //
   // We use a number of bit patterns to increase the coverage
   // of scenarios
+  constexpr int WidthMinusOne = TypeParam::kByteWidth - 1;
+
   for (int32_t start : {1, 15, /* 00001111 */
                         85,    /* 01010101 */
                         127 /* 01111111 */}) {
-    Decimal128 value(start);
-    for (int ii = 0; ii < 16; ++ii) {
+    TypeParam value(start);
+    for (int ii = 0; ii < TypeParam::kByteWidth; ++ii) {
       auto native_endian = value.ToBytes();
 #if ARROW_LITTLE_ENDIAN
       std::reverse(native_endian.begin(), native_endian.end());
@@ -1315,8 +1385,8 @@ TEST(Decimal128Test, TestFromBigEndian) {
       // sure that it works correctly. That's why all of the
       // 'start' values don't have a 1 in the most significant
       // bit place
-      ASSERT_OK_AND_EQ(value,
-                       Decimal128::FromBigEndian(native_endian.data() + 15 - ii, ii + 1));
+      ASSERT_OK_AND_EQ(value, TypeParam::FromBigEndian(
+                                  native_endian.data() + WidthMinusOne - ii, ii + 1));
 
       // Negate it
       auto negated = -value;
@@ -1326,8 +1396,8 @@ TEST(Decimal128Test, TestFromBigEndian) {
       std::reverse(native_endian.begin(), native_endian.end());
 #endif
       // The sign bit is looked up in the MSB
-      ASSERT_OK_AND_EQ(negated,
-                       Decimal128::FromBigEndian(native_endian.data() + 15 - ii, ii + 1));
+      ASSERT_OK_AND_EQ(negated, TypeParam::FromBigEndian(
+                                    native_endian.data() + WidthMinusOne - ii, ii + 1));
 
       // Take the complement
       auto complement = ~value;
@@ -1336,24 +1406,25 @@ TEST(Decimal128Test, TestFromBigEndian) {
       // convert to big endian
       std::reverse(native_endian.begin(), native_endian.end());
 #endif
-      ASSERT_OK_AND_EQ(complement, Decimal128::FromBigEndian(native_endian.data(), 16));
+      ASSERT_OK_AND_EQ(complement, TypeParam::FromBigEndian(native_endian.data(),
+                                                            TypeParam::kByteWidth));
 
-      value <<= 8;
-      value += Decimal128(start);
+      value <<= 2;
+      value += TypeParam(start);
     }
   }
 }
 
-TEST(Decimal128Test, TestFromBigEndianBadLength) {
-  ASSERT_RAISES(Invalid, Decimal128::FromBigEndian(0, -1));
-  ASSERT_RAISES(Invalid, Decimal128::FromBigEndian(0, 17));
+TYPED_TEST(TestBasicDecimalFunctionality, TestFromBigEndianBadLength) {
+  ASSERT_RAISES(Invalid, TypeParam::FromBigEndian(0, -1));
+  ASSERT_RAISES(Invalid, TypeParam::FromBigEndian(0, TypeParam::kByteWidth + 1));
 }
 
-TEST(Decimal128Test, TestToInteger) {
-  Decimal128 value1("1234");
+TYPED_TEST(TestBasicDecimalFunctionality, TestToInteger) {
+  TypeParam value1("1234");
   int32_t out1;
 
-  Decimal128 value2("-1234");
+  TypeParam value2("-1234");
   int64_t out2;
 
   ASSERT_OK(value1.ToInteger(&out1));
@@ -1367,12 +1438,6 @@ TEST(Decimal128Test, TestToInteger) {
 
   ASSERT_OK(value2.ToInteger(&out2));
   ASSERT_EQ(-1234, out2);
-
-  Decimal128 invalid_int32(static_cast<int64_t>(std::pow(2, 31)));
-  ASSERT_RAISES(Invalid, invalid_int32.ToInteger(&out1));
-
-  Decimal128 invalid_int64("12345678912345678901");
-  ASSERT_RAISES(Invalid, invalid_int64.ToInteger(&out2));
 }
 
 template <typename ArrowType, typename CType = typename ArrowType::c_type>
@@ -1389,53 +1454,61 @@ std::vector<CType> GetRandomNumbers(int32_t size) {
   return ret;
 }
 
-TEST(Decimal128Test, Multiply) {
-  ASSERT_EQ(Decimal128(60501), Decimal128(301) * Decimal128(201));
+TYPED_TEST(TestBasicDecimalFunctionality, Multiply) {
+  ASSERT_EQ(TypeParam(60501), TypeParam(301) * TypeParam(201));
 
-  ASSERT_EQ(Decimal128(-60501), Decimal128(-301) * Decimal128(201));
+  ASSERT_EQ(TypeParam(-60501), TypeParam(-301) * TypeParam(201));
 
-  ASSERT_EQ(Decimal128(-60501), Decimal128(301) * Decimal128(-201));
+  ASSERT_EQ(TypeParam(-60501), TypeParam(301) * TypeParam(-201));
 
-  ASSERT_EQ(Decimal128(60501), Decimal128(-301) * Decimal128(-201));
+  ASSERT_EQ(TypeParam(60501), TypeParam(-301) * TypeParam(-201));
 
   // Test some random numbers.
   for (auto x : GetRandomNumbers<Int32Type>(16)) {
     for (auto y : GetRandomNumbers<Int32Type>(16)) {
-      Decimal128 result = Decimal128(x) * Decimal128(y);
-      ASSERT_EQ(Decimal128(static_cast<int64_t>(x) * y), result)
+      TypeParam result = TypeParam(x) * TypeParam(y);
+      ASSERT_EQ(TypeParam(static_cast<int64_t>(x) * y), result)
           << " x: " << x << " y: " << y;
-      // Test by multiplying with an additional 32 bit factor, then additional
-      // factor of 2^30 to test results in the range of -2^123 to 2^123 without overflow.
-      for (auto z : GetRandomNumbers<Int32Type>(32)) {
-        int128_t w = static_cast<int128_t>(x) * y * (1ull << 30);
-        Decimal128 expected = Decimal128FromInt128(static_cast<int128_t>(w) * z);
-        Decimal128 actual = Decimal128FromInt128(w) * Decimal128(z);
-        ASSERT_EQ(expected, actual) << " w: " << x << " * " << y << " * 2^30 z: " << z;
+
+      // for Decimal128
+      if constexpr (std::is_same_v<TypeParam, Decimal128>) {
+        // Test by multiplying with an additional 32 bit factor, then additional
+        // factor of 2^30 to test results in the range of -2^123 to 2^123 without
+        // overflow.
+        for (auto z : GetRandomNumbers<Int32Type>(32)) {
+          int128_t w = static_cast<int128_t>(x) * y * (1ull << 30);
+          TypeParam expected = Decimal128FromInt128(static_cast<int128_t>(w) * z);
+          TypeParam actual = Decimal128FromInt128(w) * TypeParam(z);
+          ASSERT_EQ(expected, actual) << " w: " << x << " * " << y << " * 2^30 z: " << z;
+        }
       }
     }
   }
 
-  // Test some edge cases
-  for (auto x : std::vector<int128_t>{-INT64_MAX, -INT32_MAX, 0, INT32_MAX, INT64_MAX}) {
-    for (auto y :
-         std::vector<int128_t>{-INT32_MAX, -32, -2, -1, 0, 1, 2, 32, INT32_MAX}) {
-      Decimal128 decimal_x = Decimal128FromInt128(x);
-      Decimal128 decimal_y = Decimal128FromInt128(y);
-      Decimal128 result = decimal_x * decimal_y;
-      EXPECT_EQ(Decimal128FromInt128(x * y), result)
-          << " x: " << decimal_x << " y: " << decimal_y;
+  // Test edge cases for Decimal128
+  if constexpr (std::is_same_v<TypeParam, Decimal128>) {
+    for (auto x :
+         std::vector<int128_t>{-INT64_MAX, -INT32_MAX, 0, INT32_MAX, INT64_MAX}) {
+      for (auto y :
+           std::vector<int128_t>{-INT32_MAX, -32, -2, -1, 0, 1, 2, 32, INT32_MAX}) {
+        Decimal128 decimal_x = Decimal128FromInt128(x);
+        Decimal128 decimal_y = Decimal128FromInt128(y);
+        Decimal128 result = decimal_x * decimal_y;
+        EXPECT_EQ(Decimal128FromInt128(x * y), result)
+            << " x: " << decimal_x << " y: " << decimal_y;
+      }
     }
   }
 }
 
-TEST(Decimal128Test, Divide) {
-  ASSERT_EQ(Decimal128(66), Decimal128(20100) / Decimal128(301));
+TYPED_TEST(TestBasicDecimalFunctionality, Divide) {
+  ASSERT_EQ(TypeParam(66), TypeParam(20100) / TypeParam(301));
 
-  ASSERT_EQ(Decimal128(-66), Decimal128(-20100) / Decimal128(301));
+  ASSERT_EQ(TypeParam(-66), TypeParam(-20100) / TypeParam(301));
 
-  ASSERT_EQ(Decimal128(-66), Decimal128(20100) / Decimal128(-301));
+  ASSERT_EQ(TypeParam(-66), TypeParam(20100) / TypeParam(-301));
 
-  ASSERT_EQ(Decimal128(66), Decimal128(-20100) / Decimal128(-301));
+  ASSERT_EQ(TypeParam(66), TypeParam(-20100) / TypeParam(-301));
 
   // Test some random numbers.
   for (auto x : GetRandomNumbers<Int32Type>(16)) {
@@ -1444,65 +1517,75 @@ TEST(Decimal128Test, Divide) {
         continue;
       }
 
-      Decimal128 result = Decimal128(x) / Decimal128(y);
-      ASSERT_EQ(Decimal128(static_cast<int64_t>(x) / y), result)
+      TypeParam result = TypeParam(x) / TypeParam(y);
+      ASSERT_EQ(TypeParam(static_cast<int64_t>(x) / y), result)
           << " x: " << x << " y: " << y;
     }
   }
 
-  // Test some edge cases
-  for (auto x : std::vector<int128_t>{-INT64_MAX, -INT32_MAX, 0, INT32_MAX, INT64_MAX}) {
-    for (auto y : std::vector<int128_t>{-INT32_MAX, -32, -2, -1, 1, 2, 32, INT32_MAX}) {
-      Decimal128 decimal_x = Decimal128FromInt128(x);
-      Decimal128 decimal_y = Decimal128FromInt128(y);
-      Decimal128 result = decimal_x / decimal_y;
-      EXPECT_EQ(Decimal128FromInt128(x / y), result)
-          << " x: " << decimal_x << " y: " << decimal_y;
+  // Edge cases for Decimal128
+  if constexpr (std::is_same_v<TypeParam, Decimal128>) {
+    for (auto x :
+         std::vector<int128_t>{-INT64_MAX, -INT32_MAX, 0, INT32_MAX, INT64_MAX}) {
+      for (auto y : std::vector<int128_t>{-INT32_MAX, -32, -2, -1, 1, 2, 32, INT32_MAX}) {
+        Decimal128 decimal_x = Decimal128FromInt128(x);
+        Decimal128 decimal_y = Decimal128FromInt128(y);
+        Decimal128 result = decimal_x / decimal_y;
+        EXPECT_EQ(Decimal128FromInt128(x / y), result)
+            << " x: " << decimal_x << " y: " << decimal_y;
+      }
     }
   }
 }
 
-TEST(Decimal128Test, Rescale) {
-  ASSERT_OK_AND_EQ(Decimal128(11100), Decimal128(111).Rescale(0, 2));
-  ASSERT_OK_AND_EQ(Decimal128(111), Decimal128(11100).Rescale(2, 0));
-  ASSERT_OK_AND_EQ(Decimal128(5), Decimal128(500000).Rescale(6, 1));
-  ASSERT_OK_AND_EQ(Decimal128(500000), Decimal128(5).Rescale(1, 6));
-  ASSERT_RAISES(Invalid, Decimal128(555555).Rescale(6, 1));
+TYPED_TEST(TestBasicDecimalFunctionality, Rescale) {
+  ASSERT_OK_AND_EQ(TypeParam(11100), TypeParam(111).Rescale(0, 2));
+  ASSERT_OK_AND_EQ(TypeParam(111), TypeParam(11100).Rescale(2, 0));
+  ASSERT_OK_AND_EQ(TypeParam(5), TypeParam(500000).Rescale(6, 1));
+  ASSERT_OK_AND_EQ(TypeParam(500000), TypeParam(5).Rescale(1, 6));
+  ASSERT_RAISES(Invalid, TypeParam(555555).Rescale(6, 1));
+
+  using OrigScaleType =
+      std::conditional_t<std::is_same_v<TypeParam, Decimal32>, Int8Type, Int16Type>;
+  using ValueType =
+      std::conditional_t<std::is_same_v<TypeParam, Decimal32>, Int16Type, Int32Type>;
 
   // Test some random numbers.
-  for (auto original_scale : GetRandomNumbers<Int16Type>(16)) {
-    for (auto value : GetRandomNumbers<Int32Type>(16)) {
-      Decimal128 unscaled_value = Decimal128(value);
-      Decimal128 scaled_value = unscaled_value;
-      for (int32_t new_scale = original_scale; new_scale < original_scale + 29;
-           new_scale++, scaled_value *= Decimal128(10)) {
+  for (auto original_scale : GetRandomNumbers<OrigScaleType>(16)) {
+    for (auto value : GetRandomNumbers<ValueType>(16)) {
+      TypeParam unscaled_value = TypeParam(value);
+      TypeParam scaled_value = unscaled_value;
+      for (int32_t new_scale = original_scale;
+           new_scale < original_scale + (TypeParam::kMaxScale / 1.8);
+           new_scale++, scaled_value *= TypeParam(10)) {
         ASSERT_OK_AND_EQ(scaled_value, unscaled_value.Rescale(original_scale, new_scale));
         ASSERT_OK_AND_EQ(unscaled_value, scaled_value.Rescale(new_scale, original_scale));
       }
     }
   }
 
-  for (auto original_scale : GetRandomNumbers<Int16Type>(16)) {
-    Decimal128 value(1);
-    for (int32_t new_scale = original_scale; new_scale < original_scale + 39;
-         new_scale++, value *= Decimal128(10)) {
-      Decimal128 negative_value = value * -1;
-      ASSERT_OK_AND_EQ(value, Decimal128(1).Rescale(original_scale, new_scale));
-      ASSERT_OK_AND_EQ(negative_value, Decimal128(-1).Rescale(original_scale, new_scale));
-      ASSERT_OK_AND_EQ(Decimal128(1), value.Rescale(new_scale, original_scale));
-      ASSERT_OK_AND_EQ(Decimal128(-1), negative_value.Rescale(new_scale, original_scale));
+  for (auto original_scale : GetRandomNumbers<OrigScaleType>(16)) {
+    TypeParam value(1);
+    for (int32_t new_scale = original_scale;
+         new_scale < original_scale + TypeParam::kMaxScale + 1;
+         new_scale++, value *= TypeParam(10)) {
+      TypeParam negative_value = value * -1;
+      ASSERT_OK_AND_EQ(value, TypeParam(1).Rescale(original_scale, new_scale));
+      ASSERT_OK_AND_EQ(negative_value, TypeParam(-1).Rescale(original_scale, new_scale));
+      ASSERT_OK_AND_EQ(TypeParam(1), value.Rescale(new_scale, original_scale));
+      ASSERT_OK_AND_EQ(TypeParam(-1), negative_value.Rescale(new_scale, original_scale));
     }
   }
 }
 
-TEST(Decimal128Test, Mod) {
-  ASSERT_EQ(Decimal128(234), Decimal128(20100) % Decimal128(301));
+TYPED_TEST(TestBasicDecimalFunctionality, Mod) {
+  ASSERT_EQ(TypeParam(234), TypeParam(20100) % TypeParam(301));
 
-  ASSERT_EQ(Decimal128(-234), Decimal128(-20100) % Decimal128(301));
+  ASSERT_EQ(TypeParam(-234), TypeParam(-20100) % TypeParam(301));
 
-  ASSERT_EQ(Decimal128(234), Decimal128(20100) % Decimal128(-301));
+  ASSERT_EQ(TypeParam(234), TypeParam(20100) % TypeParam(-301));
 
-  ASSERT_EQ(Decimal128(-234), Decimal128(-20100) % Decimal128(-301));
+  ASSERT_EQ(TypeParam(-234), TypeParam(-20100) % TypeParam(-301));
 
   // Test some random numbers.
   for (auto x : GetRandomNumbers<Int32Type>(16)) {
@@ -1511,174 +1594,298 @@ TEST(Decimal128Test, Mod) {
         continue;
       }
 
-      Decimal128 result = Decimal128(x) % Decimal128(y);
-      ASSERT_EQ(Decimal128(static_cast<int64_t>(x) % y), result)
+      TypeParam result = TypeParam(x) % TypeParam(y);
+      ASSERT_EQ(TypeParam(static_cast<int64_t>(x) % y), result)
           << " x: " << x << " y: " << y;
     }
   }
 
-  // Test some edge cases
-  for (auto x : std::vector<int128_t>{-INT64_MAX, -INT32_MAX, 0, INT32_MAX, INT64_MAX}) {
-    for (auto y : std::vector<int128_t>{-INT32_MAX, -32, -2, -1, 1, 2, 32, INT32_MAX}) {
-      Decimal128 decimal_x = Decimal128FromInt128(x);
-      Decimal128 decimal_y = Decimal128FromInt128(y);
-      Decimal128 result = decimal_x % decimal_y;
-      EXPECT_EQ(Decimal128FromInt128(x % y), result)
-          << " x: " << decimal_x << " y: " << decimal_y;
+  // Edge cases for Decimal128
+  if constexpr (std::is_same_v<TypeParam, Decimal128>) {
+    // Test some edge cases
+    for (auto x :
+         std::vector<int128_t>{-INT64_MAX, -INT32_MAX, 0, INT32_MAX, INT64_MAX}) {
+      for (auto y : std::vector<int128_t>{-INT32_MAX, -32, -2, -1, 1, 2, 32, INT32_MAX}) {
+        Decimal128 decimal_x = Decimal128FromInt128(x);
+        Decimal128 decimal_y = Decimal128FromInt128(y);
+        Decimal128 result = decimal_x % decimal_y;
+        EXPECT_EQ(Decimal128FromInt128(x % y), result)
+            << " x: " << decimal_x << " y: " << decimal_y;
+      }
     }
   }
 }
 
-TEST(Decimal128Test, Sign) {
-  ASSERT_EQ(1, Decimal128(999999).Sign());
-  ASSERT_EQ(-1, Decimal128(-999999).Sign());
-  ASSERT_EQ(1, Decimal128(0).Sign());
+TYPED_TEST(TestBasicDecimalFunctionality, Sign) {
+  ASSERT_EQ(1, TypeParam(999999).Sign());
+  ASSERT_EQ(-1, TypeParam(-999999).Sign());
+  ASSERT_EQ(1, TypeParam(0).Sign());
 }
 
-TEST(Decimal128Test, GetWholeAndFraction) {
-  Decimal128 value("123456");
-  Decimal128 whole;
-  Decimal128 fraction;
-  int32_t out;
+TYPED_TEST(TestBasicDecimalFunctionality, GetWholeAndFraction) {
+  TypeParam value("123456");
 
-  value.GetWholeAndFraction(0, &whole, &fraction);
-  ASSERT_OK(whole.ToInteger(&out));
-  ASSERT_EQ(123456, out);
-  ASSERT_OK(fraction.ToInteger(&out));
-  ASSERT_EQ(0, out);
-
-  value.GetWholeAndFraction(1, &whole, &fraction);
-  ASSERT_OK(whole.ToInteger(&out));
-  ASSERT_EQ(12345, out);
-  ASSERT_OK(fraction.ToInteger(&out));
-  ASSERT_EQ(6, out);
-
-  value.GetWholeAndFraction(5, &whole, &fraction);
-  ASSERT_OK(whole.ToInteger(&out));
-  ASSERT_EQ(1, out);
-  ASSERT_OK(fraction.ToInteger(&out));
-  ASSERT_EQ(23456, out);
-
-  value.GetWholeAndFraction(7, &whole, &fraction);
-  ASSERT_OK(whole.ToInteger(&out));
-  ASSERT_EQ(0, out);
-  ASSERT_OK(fraction.ToInteger(&out));
-  ASSERT_EQ(123456, out);
-}
-
-TEST(Decimal128Test, GetWholeAndFractionNegative) {
-  Decimal128 value("-123456");
-  Decimal128 whole;
-  Decimal128 fraction;
-  int32_t out;
+  auto check = [value](int32_t scale, std::pair<int32_t, int32_t> expected) {
+    TypeParam whole, fraction;
+    int32_t out;
+    value.GetWholeAndFraction(scale, &whole, &fraction);
+    ASSERT_OK(whole.ToInteger(&out));
+    ASSERT_EQ(expected.first, out);
+    ASSERT_OK(fraction.ToInteger(&out));
+    ASSERT_EQ(expected.second, out);
+  };
 
-  value.GetWholeAndFraction(0, &whole, &fraction);
-  ASSERT_OK(whole.ToInteger(&out));
-  ASSERT_EQ(-123456, out);
-  ASSERT_OK(fraction.ToInteger(&out));
-  ASSERT_EQ(0, out);
+  check(0, {123456, 0});
+  check(1, {12345, 6});
+  check(5, {1, 23456});
+  check(7, {0, 123456});
+}
 
-  value.GetWholeAndFraction(1, &whole, &fraction);
-  ASSERT_OK(whole.ToInteger(&out));
-  ASSERT_EQ(-12345, out);
-  ASSERT_OK(fraction.ToInteger(&out));
-  ASSERT_EQ(-6, out);
+TYPED_TEST(TestBasicDecimalFunctionality, GetWholeAndFractionNegative) {
+  TypeParam value("-123456");
 
-  value.GetWholeAndFraction(5, &whole, &fraction);
-  ASSERT_OK(whole.ToInteger(&out));
-  ASSERT_EQ(-1, out);
-  ASSERT_OK(fraction.ToInteger(&out));
-  ASSERT_EQ(-23456, out);
+  auto check = [value](int32_t scale, std::pair<int32_t, int32_t> expected) {
+    TypeParam whole, fraction;
+    int32_t out;
+    value.GetWholeAndFraction(scale, &whole, &fraction);
+    ASSERT_OK(whole.ToInteger(&out));
+    ASSERT_EQ(expected.first, out);
+    ASSERT_OK(fraction.ToInteger(&out));
+    ASSERT_EQ(expected.second, out);
+  };
 
-  value.GetWholeAndFraction(7, &whole, &fraction);
-  ASSERT_OK(whole.ToInteger(&out));
-  ASSERT_EQ(0, out);
-  ASSERT_OK(fraction.ToInteger(&out));
-  ASSERT_EQ(-123456, out);
+  check(0, {-123456, 0});
+  check(1, {-12345, -6});
+  check(5, {-1, -23456});
+  check(7, {0, -123456});
 }
 
-TEST(Decimal128Test, IncreaseScale) {
-  Decimal128 result;
+TYPED_TEST(TestBasicDecimalFunctionality, IncreaseScale) {
+  TypeParam result;
   int32_t out;
 
-  result = Decimal128("1234").IncreaseScaleBy(0);
+  result = TypeParam("1234").IncreaseScaleBy(0);
   ASSERT_OK(result.ToInteger(&out));
   ASSERT_EQ(1234, out);
 
-  result = Decimal128("1234").IncreaseScaleBy(3);
+  result = TypeParam("1234").IncreaseScaleBy(3);
   ASSERT_OK(result.ToInteger(&out));
   ASSERT_EQ(1234000, out);
 
-  result = Decimal128("-1234").IncreaseScaleBy(3);
+  result = TypeParam("-1234").IncreaseScaleBy(3);
   ASSERT_OK(result.ToInteger(&out));
   ASSERT_EQ(-1234000, out);
 }
 
-TEST(Decimal128Test, ReduceScaleAndRound) {
-  Decimal128 result;
-  int32_t out;
+TYPED_TEST(TestBasicDecimalFunctionality, ReduceScaleAndRound) {
+  auto check = [](std::string val, int32_t reduce_by, bool round, int32_t expected) {
+    int32_t out;
 
-  result = Decimal128("123456").ReduceScaleBy(0);
-  ASSERT_OK(result.ToInteger(&out));
-  ASSERT_EQ(123456, out);
+    TypeParam result = TypeParam(val).ReduceScaleBy(reduce_by, round);
+    ASSERT_OK(result.ToInteger(&out));
+    ASSERT_EQ(expected, out);
+  };
 
-  result = Decimal128("123456").ReduceScaleBy(1, false);
-  ASSERT_OK(result.ToInteger(&out));
-  ASSERT_EQ(12345, out);
+  check("123456", 0, false, 123456);
+  check("123456", 1, false, 12345);
+  check("123456", 1, true, 12346);
+  check("123451", 1, true, 12345);
+  check("5", 1, true, 1);
+  check("0", 1, true, 0);
+  check("-123789", 2, true, -1238);
+  check("-123749", 2, true, -1237);
+  check("-123750", 2, true, -1238);
+  check("-5", 1, true, -1);
+}
+
+TYPED_TEST(TestBasicDecimalFunctionality, FitsInPrecision) {
+  ASSERT_TRUE(TypeParam("0").FitsInPrecision(1));
+  ASSERT_TRUE(TypeParam("9").FitsInPrecision(1));
+  ASSERT_TRUE(TypeParam("-9").FitsInPrecision(1));
+  ASSERT_FALSE(TypeParam("10").FitsInPrecision(1));
+  ASSERT_FALSE(TypeParam("-10").FitsInPrecision(1));
+
+  ASSERT_TRUE(TypeParam("0").FitsInPrecision(2));
+  ASSERT_TRUE(TypeParam("10").FitsInPrecision(2));
+  ASSERT_TRUE(TypeParam("-10").FitsInPrecision(2));
+  ASSERT_TRUE(TypeParam("99").FitsInPrecision(2));
+  ASSERT_TRUE(TypeParam("-99").FitsInPrecision(2));
+  ASSERT_FALSE(TypeParam("100").FitsInPrecision(2));
+  ASSERT_FALSE(TypeParam("-100").FitsInPrecision(2));
+
+  std::string max_nines(TypeParam::kMaxPrecision, '9');
+  ASSERT_TRUE(TypeParam(max_nines).FitsInPrecision(TypeParam::kMaxPrecision));
+  ASSERT_TRUE(TypeParam("-" + max_nines).FitsInPrecision(TypeParam::kMaxPrecision));
+
+  std::string max_zeros(TypeParam::kMaxPrecision, '0');
+  ASSERT_FALSE(TypeParam("1" + max_zeros).FitsInPrecision(TypeParam::kMaxPrecision));
+  ASSERT_FALSE(TypeParam("-1" + max_zeros).FitsInPrecision(TypeParam::kMaxPrecision));
+}
+
+TEST(Decimal32Test, LeftShift) {
+  auto check = [](int32_t x, uint32_t bits) {
+    auto expected = Decimal32(x << bits);
+    auto actual = Decimal32(x) << bits;
+    ASSERT_EQ(actual.value(), expected.value());
+  };
 
-  result = Decimal128("123456").ReduceScaleBy(1, true);
-  ASSERT_OK(result.ToInteger(&out));
-  ASSERT_EQ(12346, out);
+  ASSERT_EQ(Decimal32("0"), Decimal32("0") << 0);
+  ASSERT_EQ(Decimal32("0"), Decimal32("0") << 1);
+  ASSERT_EQ(Decimal32("0"), Decimal32("0") << 15);
+  ASSERT_EQ(Decimal32("0"), Decimal32("0") << 31);
 
-  result = Decimal128("123451").ReduceScaleBy(1, true);
-  ASSERT_OK(result.ToInteger(&out));
-  ASSERT_EQ(12345, out);
+  check(123, 0);
+  check(123, 1);
+  check(123, 15);
+  check(123, 16);
+  check(123, 30);
 
-  result = Decimal128("5").ReduceScaleBy(1, true);
-  ASSERT_OK(result.ToInteger(&out));
-  ASSERT_EQ(1, out);
+  ASSERT_EQ(Decimal32("1999999998"), Decimal32("999999999") << 1);
+  ASSERT_EQ(Decimal32("12799872"), Decimal32("99999") << 7);
+  ASSERT_EQ(Decimal32("1638383616"), Decimal32("99999") << 14);
 
-  result = Decimal128("0").ReduceScaleBy(1, true);
-  ASSERT_OK(result.ToInteger(&out));
-  ASSERT_EQ(0, out);
+  ASSERT_EQ(Decimal32("123456789"), Decimal32("123456789") << 0);
+  ASSERT_EQ(Decimal32("246913578"), Decimal32("123456789") << 1);
+  ASSERT_EQ(Decimal32("877920256"), Decimal32("123456789") << 18);
 
-  result = Decimal128("-123789").ReduceScaleBy(2, true);
-  ASSERT_OK(result.ToInteger(&out));
-  ASSERT_EQ(-1238, out);
+  check(-123, 0);
+  check(-123, 1);
+  check(-123, 15);
+  check(-123, 16);
+  check(-123, 30);
+
+  ASSERT_EQ(Decimal32("-1999999998"), Decimal32("-999999999") << 1);
+  ASSERT_EQ(Decimal32("-12799872"), Decimal32("-99999") << 7);
+  ASSERT_EQ(Decimal32("-1638383616"), Decimal32("-99999") << 14);
+
+  ASSERT_EQ(Decimal32("-123456789"), Decimal32("-123456789") << 0);
+  ASSERT_EQ(Decimal32("-246913578"), Decimal32("-123456789") << 1);
+  ASSERT_EQ(Decimal32("-877920256"), Decimal32("-123456789") << 18);
+}
+
+TEST(Decimal32Test, RightShift) {
+  ASSERT_EQ(Decimal32("0"), Decimal32("0") >> 0);
+  ASSERT_EQ(Decimal32("0"), Decimal32("0") >> 1);
+  ASSERT_EQ(Decimal32("0"), Decimal32("0") >> 15);
+  ASSERT_EQ(Decimal32("0"), Decimal32("0") >> 31);
+
+  ASSERT_EQ(Decimal32("1"), Decimal32("1") >> 0);
+  ASSERT_EQ(Decimal32("0"), Decimal32("1") >> 1);
+  ASSERT_EQ(Decimal32("0"), Decimal32("1") >> 15);
+  ASSERT_EQ(Decimal32("0"), Decimal32("1") >> 31);
+
+  ASSERT_EQ(Decimal32("-1"), Decimal32("-1") >> 0);
+  ASSERT_EQ(Decimal32("-1"), Decimal32("-1") >> 1);
+  ASSERT_EQ(Decimal32("-1"), Decimal32("-1") >> 15);
+  ASSERT_EQ(Decimal32("-1"), Decimal32("-1") >> 31);
+
+  ASSERT_EQ(Decimal32("120563"), Decimal32("123456789") >> 10);
+  ASSERT_EQ(Decimal32("1883"), Decimal32("123456789") >> 16);
+  ASSERT_EQ(Decimal32("117"), Decimal32("123456789") >> 20);
+  ASSERT_EQ(Decimal32("0"), Decimal32("123456789") >> 30);
+  ASSERT_EQ(Decimal32("0"), Decimal32("123456789") >> 31);
+
+  ASSERT_EQ(Decimal32("-120564"), Decimal32("-123456789") >> 10);
+  ASSERT_EQ(Decimal32("-1884"), Decimal32("-123456789") >> 16);
+  ASSERT_EQ(Decimal32("-118"), Decimal32("-123456789") >> 20);
+  ASSERT_EQ(Decimal32("-1"), Decimal32("-123456789") >> 30);
+  ASSERT_EQ(Decimal32("-1"), Decimal32("-123456789") >> 31);
+}
+
+TEST(Decimal32Test, Negate) {
+  auto check = [](Decimal32 pos, Decimal32 neg) {
+    EXPECT_EQ(-pos, neg);
+    EXPECT_EQ(-neg, pos);
+  };
 
-  result = Decimal128("-123749").ReduceScaleBy(2, true);
-  ASSERT_OK(result.ToInteger(&out));
-  ASSERT_EQ(-1237, out);
+  check(Decimal32(0), Decimal32(0));
+  check(Decimal32(1), Decimal32(0xFFFFFFFF));
+  check(Decimal32(2), Decimal32(0xFFFFFFFE));
+  check(Decimal32(0x8000000), Decimal32(0xF8000000));
+  check(Decimal32(12), Decimal32(-12));
+}
 
-  result = Decimal128("-123750").ReduceScaleBy(2, true);
-  ASSERT_OK(result.ToInteger(&out));
-  ASSERT_EQ(-1238, out);
+TEST(Decimal64Test, LeftShift) {
+  auto check = [](int64_t x, uint32_t bits) {
+    auto expected = Decimal64(x << bits);
+    auto actual = Decimal64(x) << bits;
+    ASSERT_EQ(actual.value(), expected.value());
+  };
 
-  result = Decimal128("-5").ReduceScaleBy(1, true);
-  ASSERT_OK(result.ToInteger(&out));
-  ASSERT_EQ(-1, out);
-}
-
-TEST(Decimal128Test, FitsInPrecision) {
-  ASSERT_TRUE(Decimal128("0").FitsInPrecision(1));
-  ASSERT_TRUE(Decimal128("9").FitsInPrecision(1));
-  ASSERT_TRUE(Decimal128("-9").FitsInPrecision(1));
-  ASSERT_FALSE(Decimal128("10").FitsInPrecision(1));
-  ASSERT_FALSE(Decimal128("-10").FitsInPrecision(1));
-
-  ASSERT_TRUE(Decimal128("0").FitsInPrecision(2));
-  ASSERT_TRUE(Decimal128("10").FitsInPrecision(2));
-  ASSERT_TRUE(Decimal128("-10").FitsInPrecision(2));
-  ASSERT_TRUE(Decimal128("99").FitsInPrecision(2));
-  ASSERT_TRUE(Decimal128("-99").FitsInPrecision(2));
-  ASSERT_FALSE(Decimal128("100").FitsInPrecision(2));
-  ASSERT_FALSE(Decimal128("-100").FitsInPrecision(2));
-
-  ASSERT_TRUE(Decimal128("99999999999999999999999999999999999999").FitsInPrecision(38));
-  ASSERT_TRUE(Decimal128("-99999999999999999999999999999999999999").FitsInPrecision(38));
-  ASSERT_FALSE(Decimal128("100000000000000000000000000000000000000").FitsInPrecision(38));
-  ASSERT_FALSE(
-      Decimal128("-100000000000000000000000000000000000000").FitsInPrecision(38));
+  ASSERT_EQ(Decimal64("0"), Decimal64("0") << 0);
+  ASSERT_EQ(Decimal64("0"), Decimal64("0") << 1);
+  ASSERT_EQ(Decimal64("0"), Decimal64("0") << 15);
+  ASSERT_EQ(Decimal64("0"), Decimal64("0") << 31);
+
+  check(123, 0);
+  check(123, 1);
+  check(123, 31);
+  check(123, 32);
+  check(123, 62);
+
+  ASSERT_EQ(Decimal64("19999999998"), Decimal64("9999999999") << 1);
+  ASSERT_EQ(Decimal64("327679999967232"), Decimal64("9999999999") << 15);
+  ASSERT_EQ(Decimal64("167772159983222784"), Decimal64("9999999999") << 24);
+
+  ASSERT_EQ(Decimal64("1234567890123456"), Decimal64("1234567890123456") << 0);
+  ASSERT_EQ(Decimal64("2469135780246912"), Decimal64("1234567890123456") << 1);
+  ASSERT_EQ(Decimal64("6917529027641081856"), Decimal64("1234567890123456") << 55);
+
+  check(-123, 0);
+  check(-123, 1);
+  check(-123, 31);
+  check(-123, 32);
+  check(-123, 62);
+
+  ASSERT_EQ(Decimal64("-19999999998"), Decimal64("-9999999999") << 1);
+  ASSERT_EQ(Decimal64("-327679999967232"), Decimal64("-9999999999") << 15);
+  ASSERT_EQ(Decimal64("-167772159983222784"), Decimal64("-9999999999") << 24);
+
+  ASSERT_EQ(Decimal64("-1234567890123456"), Decimal64("-1234567890123456") << 0);
+  ASSERT_EQ(Decimal64("-2469135780246912"), Decimal64("-1234567890123456") << 1);
+  ASSERT_EQ(Decimal64("-6917529027641081856"), Decimal64("-1234567890123456") << 55);
+}
+
+TEST(Decimal64Test, RightShift) {
+  ASSERT_EQ(Decimal64("0"), Decimal64("0") >> 0);
+  ASSERT_EQ(Decimal64("0"), Decimal64("0") >> 1);
+  ASSERT_EQ(Decimal64("0"), Decimal64("0") >> 31);
+  ASSERT_EQ(Decimal64("0"), Decimal64("0") >> 63);
+
+  ASSERT_EQ(Decimal64("1"), Decimal64("1") >> 0);
+  ASSERT_EQ(Decimal64("0"), Decimal64("1") >> 1);
+  ASSERT_EQ(Decimal64("0"), Decimal64("1") >> 31);
+  ASSERT_EQ(Decimal64("0"), Decimal64("1") >> 63);
+
+  ASSERT_EQ(Decimal64("-1"), Decimal64("-1") >> 0);
+  ASSERT_EQ(Decimal64("-1"), Decimal64("-1") >> 1);
+  ASSERT_EQ(Decimal64("-1"), Decimal64("-1") >> 31);
+  ASSERT_EQ(Decimal64("-1"), Decimal64("-1") >> 63);
+
+  ASSERT_EQ(Decimal64("18838011018"), Decimal64("1234567890123456") >> 16);
+  ASSERT_EQ(Decimal64("287445"), Decimal64("1234567890123456") >> 32);
+  ASSERT_EQ(Decimal64("4"), Decimal64("1234567890123456") >> 48);
+  ASSERT_EQ(Decimal64("0"), Decimal64("1234567890123456") >> 55);
+  ASSERT_EQ(Decimal64("0"), Decimal64("1234567890123456") >> 63);
+
+  ASSERT_EQ(Decimal64("-18838011019"), Decimal64("-1234567890123456") >> 16);
+  ASSERT_EQ(Decimal64("-287446"), Decimal64("-1234567890123456") >> 32);
+  ASSERT_EQ(Decimal64("-5"), Decimal64("-1234567890123456") >> 48);
+  ASSERT_EQ(Decimal64("-1"), Decimal64("-1234567890123456") >> 55);
+  ASSERT_EQ(Decimal64("-1"), Decimal64("-1234567890123456") >> 63);
+}
+
+TEST(Decimal64Test, Negate) {
+  auto check = [](Decimal64 pos, Decimal64 neg) {
+    EXPECT_EQ(-pos, neg);
+    EXPECT_EQ(-neg, pos);
+  };
+
+  check(Decimal64(0), Decimal64(0));
+  check(Decimal64(1), Decimal64(0xFFFFFFFFFFFFFFFFLL));
+  check(Decimal64(2), Decimal64(0xFFFFFFFFFFFFFFFELL));
+  check(Decimal64(0x800000000000000), Decimal64(0xF800000000000000));
+  check(Decimal64(12), Decimal64(-12));
 }
 
 TEST(Decimal128Test, LeftShift) {
diff --git a/cpp/src/arrow/util/formatting.h b/cpp/src/arrow/util/formatting.h
index dd9af907ecc37..f2e3622ce60d5 100644
--- a/cpp/src/arrow/util/formatting.h
+++ b/cpp/src/arrow/util/formatting.h
@@ -105,6 +105,18 @@ class DecimalToStringFormatterMixin {
   int32_t scale_;
 };
 
+template <>
+class StringFormatter<Decimal32Type>
+    : public DecimalToStringFormatterMixin<Decimal32Type> {
+  using DecimalToStringFormatterMixin::DecimalToStringFormatterMixin;
+};
+
+template <>
+class StringFormatter<Decimal64Type>
+    : public DecimalToStringFormatterMixin<Decimal64Type> {
+  using DecimalToStringFormatterMixin::DecimalToStringFormatterMixin;
+};
+
 template <>
 class StringFormatter<Decimal128Type>
     : public DecimalToStringFormatterMixin<Decimal128Type> {
diff --git a/cpp/src/arrow/util/formatting_util_test.cc b/cpp/src/arrow/util/formatting_util_test.cc
index f5ae789b23651..f1846e279aca2 100644
--- a/cpp/src/arrow/util/formatting_util_test.cc
+++ b/cpp/src/arrow/util/formatting_util_test.cc
@@ -383,15 +383,27 @@ void TestDecimalFormatter() {
   };
 
   for (const auto& data : decimalTestData) {
+    using value_type = typename TypeTraits<T>::CType;
+    if (data.scale > value_type::kMaxScale) {
+      continue;
+    }
+
+    if constexpr (std::is_same_v<T, Decimal32Type>) {
+      if (data.test_value > 999999999 || data.test_value < -999999999) {
+        continue;
+      }
+    }
+
     const auto type = T(T::kMaxPrecision, data.scale);
     StringFormatter<T> formatter(&type);
-    using value_type = typename TypeTraits<T>::CType;
 
     AssertFormatting(formatter, value_type(data.test_value), data.expected_string);
   }
 }
 
 TEST(Formatting, Decimals) {
+  TestDecimalFormatter<Decimal32Type>();
+  TestDecimalFormatter<Decimal64Type>();
   TestDecimalFormatter<Decimal128Type>();
   TestDecimalFormatter<Decimal256Type>();
 }
diff --git a/cpp/src/arrow/visitor.cc b/cpp/src/arrow/visitor.cc
index cca99033c9350..95683e462fab9 100644
--- a/cpp/src/arrow/visitor.cc
+++ b/cpp/src/arrow/visitor.cc
@@ -71,6 +71,8 @@ ARRAY_VISITOR_DEFAULT(StructArray)
 ARRAY_VISITOR_DEFAULT(SparseUnionArray)
 ARRAY_VISITOR_DEFAULT(DenseUnionArray)
 ARRAY_VISITOR_DEFAULT(DictionaryArray)
+ARRAY_VISITOR_DEFAULT(Decimal32Array)
+ARRAY_VISITOR_DEFAULT(Decimal64Array)
 ARRAY_VISITOR_DEFAULT(Decimal128Array)
 ARRAY_VISITOR_DEFAULT(Decimal256Array)
 ARRAY_VISITOR_DEFAULT(RunEndEncodedArray)
@@ -115,6 +117,8 @@ TYPE_VISITOR_DEFAULT(DayTimeIntervalType)
 TYPE_VISITOR_DEFAULT(MonthDayNanoIntervalType)
 TYPE_VISITOR_DEFAULT(MonthIntervalType)
 TYPE_VISITOR_DEFAULT(DurationType)
+TYPE_VISITOR_DEFAULT(Decimal32Type)
+TYPE_VISITOR_DEFAULT(Decimal64Type)
 TYPE_VISITOR_DEFAULT(Decimal128Type)
 TYPE_VISITOR_DEFAULT(Decimal256Type)
 TYPE_VISITOR_DEFAULT(ListType)
@@ -170,6 +174,8 @@ SCALAR_VISITOR_DEFAULT(DayTimeIntervalScalar)
 SCALAR_VISITOR_DEFAULT(MonthDayNanoIntervalScalar)
 SCALAR_VISITOR_DEFAULT(MonthIntervalScalar)
 SCALAR_VISITOR_DEFAULT(DurationScalar)
+SCALAR_VISITOR_DEFAULT(Decimal32Scalar)
+SCALAR_VISITOR_DEFAULT(Decimal64Scalar)
 SCALAR_VISITOR_DEFAULT(Decimal128Scalar)
 SCALAR_VISITOR_DEFAULT(Decimal256Scalar)
 SCALAR_VISITOR_DEFAULT(ListScalar)
diff --git a/cpp/src/arrow/visitor.h b/cpp/src/arrow/visitor.h
index 75ef46ae4e5c3..87f23b2bbe800 100644
--- a/cpp/src/arrow/visitor.h
+++ b/cpp/src/arrow/visitor.h
@@ -60,6 +60,8 @@ class ARROW_EXPORT ArrayVisitor {
   virtual Status Visit(const MonthDayNanoIntervalArray& array);
   virtual Status Visit(const MonthIntervalArray& array);
   virtual Status Visit(const DurationArray& array);
+  virtual Status Visit(const Decimal32Array& array);
+  virtual Status Visit(const Decimal64Array& array);
   virtual Status Visit(const Decimal128Array& array);
   virtual Status Visit(const Decimal256Array& array);
   virtual Status Visit(const ListArray& array);
@@ -113,6 +115,8 @@ class ARROW_EXPORT TypeVisitor {
   virtual Status Visit(const MonthIntervalType& type);
   virtual Status Visit(const DayTimeIntervalType& type);
   virtual Status Visit(const DurationType& type);
+  virtual Status Visit(const Decimal32Type& type);
+  virtual Status Visit(const Decimal64Type& type);
   virtual Status Visit(const Decimal128Type& type);
   virtual Status Visit(const Decimal256Type& type);
   virtual Status Visit(const ListType& type);
@@ -166,6 +170,8 @@ class ARROW_EXPORT ScalarVisitor {
   virtual Status Visit(const MonthDayNanoIntervalScalar& type);
   virtual Status Visit(const MonthIntervalScalar& scalar);
   virtual Status Visit(const DurationScalar& scalar);
+  virtual Status Visit(const Decimal32Scalar& scalar);
+  virtual Status Visit(const Decimal64Scalar& scalar);
   virtual Status Visit(const Decimal128Scalar& scalar);
   virtual Status Visit(const Decimal256Scalar& scalar);
   virtual Status Visit(const ListScalar& scalar);
diff --git a/cpp/src/arrow/visitor_generate.h b/cpp/src/arrow/visitor_generate.h
index cbb081bfed311..a87a97764845d 100644
--- a/cpp/src/arrow/visitor_generate.h
+++ b/cpp/src/arrow/visitor_generate.h
@@ -55,6 +55,8 @@ namespace arrow {
   ACTION(MonthDayNanoInterval);                 \
   ACTION(MonthInterval);                        \
   ACTION(DayTimeInterval);                      \
+  ACTION(Decimal32);                            \
+  ACTION(Decimal64);                            \
   ACTION(Decimal128);                           \
   ACTION(Decimal256);                           \
   ACTION(List);                                 \
diff --git a/cpp/src/gandiva/decimal_type_util.h b/cpp/src/gandiva/decimal_type_util.h
index 16ce544717e46..2064672f6c3bb 100644
--- a/cpp/src/gandiva/decimal_type_util.h
+++ b/cpp/src/gandiva/decimal_type_util.h
@@ -76,7 +76,7 @@ class GANDIVA_EXPORT DecimalTypeUtil {
 
   static Decimal128TypePtr MakeType(int32_t precision, int32_t scale) {
     return std::dynamic_pointer_cast<arrow::Decimal128Type>(
-        arrow::decimal(precision, scale));
+        arrow::decimal128(precision, scale));
   }
 
  private:
diff --git a/cpp/src/gandiva/expr_validator.cc b/cpp/src/gandiva/expr_validator.cc
index cd76ffe08234e..27b27fbe25adf 100644
--- a/cpp/src/gandiva/expr_validator.cc
+++ b/cpp/src/gandiva/expr_validator.cc
@@ -188,7 +188,7 @@ Status ExprValidator::Visit(const InExpressionNode<double>& node) {
 
 Status ExprValidator::Visit(const InExpressionNode<gandiva::DecimalScalar128>& node) {
   return ValidateInExpression(node.values().size(), node.eval_expr()->return_type(),
-                              arrow::decimal(node.get_precision(), node.get_scale()));
+                              arrow::decimal128(node.get_precision(), node.get_scale()));
 }
 
 Status ExprValidator::Visit(const InExpressionNode<std::string>& node) {
diff --git a/cpp/src/gandiva/expression_registry.cc b/cpp/src/gandiva/expression_registry.cc
index dd964a7cb8a7a..d6176fe48b6ba 100644
--- a/cpp/src/gandiva/expression_registry.cc
+++ b/cpp/src/gandiva/expression_registry.cc
@@ -158,7 +158,7 @@ static void AddArrowTypesToVector(arrow::Type::type type, DataTypeVector& vector
       vector.push_back(arrow::null());
       break;
     case arrow::Type::type::DECIMAL:
-      vector.push_back(arrow::decimal(38, 0));
+      vector.push_back(arrow::decimal128(38, 0));
       break;
     case arrow::Type::type::INTERVAL_MONTHS:
       vector.push_back(arrow::month_interval());
diff --git a/cpp/src/gandiva/function_registry_common.h b/cpp/src/gandiva/function_registry_common.h
index 6fa51b498d120..abe861e3385e9 100644
--- a/cpp/src/gandiva/function_registry_common.h
+++ b/cpp/src/gandiva/function_registry_common.h
@@ -55,7 +55,7 @@ inline DataTypePtr time32() { return arrow::time32(arrow::TimeUnit::MILLI); }
 inline DataTypePtr time64() { return arrow::time64(arrow::TimeUnit::MICRO); }
 
 inline DataTypePtr timestamp() { return arrow::timestamp(arrow::TimeUnit::MILLI); }
-inline DataTypePtr decimal128() { return arrow::decimal(38, 0); }
+inline DataTypePtr decimal128() { return arrow::decimal128(38, 0); }
 
 struct KeyHash {
   std::size_t operator()(const FunctionSignature* k) const { return k->Hash(); }
diff --git a/cpp/src/gandiva/llvm_generator.cc b/cpp/src/gandiva/llvm_generator.cc
index 4afa2935ace33..e0223c4d04dfc 100644
--- a/cpp/src/gandiva/llvm_generator.cc
+++ b/cpp/src/gandiva/llvm_generator.cc
@@ -751,7 +751,7 @@ void LLVMGenerator::Visitor::Visit(const LiteralDex& dex) {
       auto int128_value =
           llvm::ConstantInt::get(llvm::Type::getInt128Ty(*generator_->context()),
                                  Decimal128(scalar.value()).ToIntegerString(), 10);
-      auto type = arrow::decimal(scalar.precision(), scalar.scale());
+      auto type = arrow::decimal128(scalar.precision(), scalar.scale());
       auto lvalue = generator_->BuildDecimalLValue(int128_value, type);
       // set it as the l-value and return.
       result_ = lvalue;
diff --git a/cpp/src/gandiva/tests/decimal_test.cc b/cpp/src/gandiva/tests/decimal_test.cc
index 1924f5b40827c..89ad020a61909 100644
--- a/cpp/src/gandiva/tests/decimal_test.cc
+++ b/cpp/src/gandiva/tests/decimal_test.cc
@@ -364,25 +364,25 @@ TEST_F(TestDecimal, TestRoundFunctions) {
   auto exprs = std::vector<ExpressionPtr>{
       TreeExprBuilder::MakeExpression("abs", {field_a}, field("res_abs", decimal_type)),
       TreeExprBuilder::MakeExpression("ceil", {field_a},
-                                      field("res_ceil", arrow::decimal(precision, 0))),
-      TreeExprBuilder::MakeExpression("floor", {field_a},
-                                      field("res_floor", arrow::decimal(precision, 0))),
-      TreeExprBuilder::MakeExpression("round", {field_a},
-                                      field("res_round", arrow::decimal(precision, 0))),
+                                      field("res_ceil", arrow::decimal128(precision, 0))),
       TreeExprBuilder::MakeExpression(
-          "truncate", {field_a}, field("res_truncate", arrow::decimal(precision, 0))),
+          "floor", {field_a}, field("res_floor", arrow::decimal128(precision, 0))),
+      TreeExprBuilder::MakeExpression(
+          "round", {field_a}, field("res_round", arrow::decimal128(precision, 0))),
+      TreeExprBuilder::MakeExpression(
+          "truncate", {field_a}, field("res_truncate", arrow::decimal128(precision, 0))),
 
       TreeExprBuilder::MakeExpression(
           TreeExprBuilder::MakeFunction("round",
                                         {TreeExprBuilder::MakeField(field_a), scale_1},
-                                        arrow::decimal(precision, 1)),
-          field("res_round_3", arrow::decimal(precision, 1))),
+                                        arrow::decimal128(precision, 1)),
+          field("res_round_3", arrow::decimal128(precision, 1))),
 
       TreeExprBuilder::MakeExpression(
           TreeExprBuilder::MakeFunction("truncate",
                                         {TreeExprBuilder::MakeField(field_a), scale_1},
-                                        arrow::decimal(precision, 1)),
-          field("res_truncate_3", arrow::decimal(precision, 1))),
+                                        arrow::decimal128(precision, 1)),
+          field("res_truncate_3", arrow::decimal128(precision, 1))),
   };
 
   // Build a projector for the expression.
@@ -416,38 +416,38 @@ TEST_F(TestDecimal, TestRoundFunctions) {
 
   // ceil(x)
   EXPECT_ARROW_ARRAY_EQUALS(
-      MakeArrowArrayDecimal(arrow::decimal(precision, 0),
+      MakeArrowArrayDecimal(arrow::decimal128(precision, 0),
                             MakeDecimalVector({"2", "2", "-1", "-1"}, 0), validity),
       outputs[1]);
 
   // floor(x)
   EXPECT_ARROW_ARRAY_EQUALS(
-      MakeArrowArrayDecimal(arrow::decimal(precision, 0),
+      MakeArrowArrayDecimal(arrow::decimal128(precision, 0),
                             MakeDecimalVector({"1", "1", "-2", "-2"}, 0), validity),
       outputs[2]);
 
   // round(x)
   EXPECT_ARROW_ARRAY_EQUALS(
-      MakeArrowArrayDecimal(arrow::decimal(precision, 0),
+      MakeArrowArrayDecimal(arrow::decimal128(precision, 0),
                             MakeDecimalVector({"1", "2", "-1", "-2"}, 0), validity),
       outputs[3]);
 
   // truncate(x)
   EXPECT_ARROW_ARRAY_EQUALS(
-      MakeArrowArrayDecimal(arrow::decimal(precision, 0),
+      MakeArrowArrayDecimal(arrow::decimal128(precision, 0),
                             MakeDecimalVector({"1", "1", "-1", "-1"}, 0), validity),
       outputs[4]);
 
   // round(x, 1)
   EXPECT_ARROW_ARRAY_EQUALS(
-      MakeArrowArrayDecimal(arrow::decimal(precision, 1),
+      MakeArrowArrayDecimal(arrow::decimal128(precision, 1),
                             MakeDecimalVector({"1.2", "1.6", "-1.2", "-1.6"}, 1),
                             validity),
       outputs[5]);
 
   // truncate(x, 1)
   EXPECT_ARROW_ARRAY_EQUALS(
-      MakeArrowArrayDecimal(arrow::decimal(precision, 1),
+      MakeArrowArrayDecimal(arrow::decimal128(precision, 1),
                             MakeDecimalVector({"1.2", "1.5", "-1.2", "-1.5"}, 1),
                             validity),
       outputs[6]);
@@ -532,7 +532,7 @@ TEST_F(TestDecimal, TestCastFunctions) {
 
   // castDECIMAL(decimal)
   EXPECT_ARROW_ARRAY_EQUALS(
-      MakeArrowArrayDecimal(arrow::decimal(precision, 1),
+      MakeArrowArrayDecimal(arrow::decimal128(precision, 1),
                             MakeDecimalVector({"1.2", "1.6", "-1.2", "-1.6"}, 1),
                             validity),
       outputs[4]);
@@ -1157,14 +1157,14 @@ TEST_F(TestDecimal, TestCastDecimalOverflow) {
   // Validate results
   // castDECIMAL(decimal)
   EXPECT_ARROW_ARRAY_EQUALS(
-      MakeArrowArrayDecimal(arrow::decimal(precision_out, 1),
+      MakeArrowArrayDecimal(arrow::decimal128(precision_out, 1),
                             MakeDecimalVector({"1.2", "0.0", "-1.2", "-1.6"}, 1),
                             validity),
       outputs[0]);
 
   // castDECIMALNullOnOverflow(decimal)
   EXPECT_ARROW_ARRAY_EQUALS(
-      MakeArrowArrayDecimal(arrow::decimal(precision_out, 1),
+      MakeArrowArrayDecimal(arrow::decimal128(precision_out, 1),
                             MakeDecimalVector({"1.2", "1.6", "-1.2", "-1.6"}, 1),
                             {true, false, true, true}),
       outputs[1]);
diff --git a/cpp/src/gandiva/tests/in_expr_test.cc b/cpp/src/gandiva/tests/in_expr_test.cc
index 675b7b465e069..3ac2165f3a544 100644
--- a/cpp/src/gandiva/tests/in_expr_test.cc
+++ b/cpp/src/gandiva/tests/in_expr_test.cc
@@ -180,7 +180,7 @@ TEST_F(TestIn, TestInDecimal) {
   auto decimal_type = std::make_shared<arrow::Decimal128Type>(precision, scale);
 
   // schema for input fields
-  auto field0 = field("f0", arrow::decimal(precision, scale));
+  auto field0 = field("f0", arrow::decimal128(precision, scale));
   auto schema = arrow::schema({field0});
 
   // Build In f0 + f1 in (6, 11)
diff --git a/cpp/src/gandiva/tests/projector_test.cc b/cpp/src/gandiva/tests/projector_test.cc
index a22d04ac28f47..9bf568f841c8c 100644
--- a/cpp/src/gandiva/tests/projector_test.cc
+++ b/cpp/src/gandiva/tests/projector_test.cc
@@ -177,7 +177,7 @@ TEST_F(TestProjector, TestProjectCacheFloat) {
 
 TEST_F(TestProjector, TestProjectCacheLiteral) {
   auto schema = arrow::schema({});
-  auto res = field("result", arrow::decimal(38, 5));
+  auto res = field("result", arrow::decimal128(38, 5));
 
   DecimalScalar128 d0("12345678", 38, 5);
   DecimalScalar128 d1("98756432", 38, 5);
@@ -199,21 +199,21 @@ TEST_F(TestProjector, TestProjectCacheDecimalCast) {
   auto field_float64 = field("float64", arrow::float64());
   auto schema = arrow::schema({field_float64});
 
-  auto res_31_13 = field("result", arrow::decimal(31, 13));
+  auto res_31_13 = field("result", arrow::decimal128(31, 13));
   auto expr0 = TreeExprBuilder::MakeExpression("castDECIMAL", {field_float64}, res_31_13);
   std::shared_ptr<Projector> projector0;
   ASSERT_OK(Projector::Make(schema, {expr0}, TestConfiguration(), &projector0));
   EXPECT_FALSE(projector0->GetBuiltFromCache());
 
   // if the output scale is different, the cache can't be used.
-  auto res_31_14 = field("result", arrow::decimal(31, 14));
+  auto res_31_14 = field("result", arrow::decimal128(31, 14));
   auto expr1 = TreeExprBuilder::MakeExpression("castDECIMAL", {field_float64}, res_31_14);
   std::shared_ptr<Projector> projector1;
   ASSERT_OK(Projector::Make(schema, {expr1}, TestConfiguration(), &projector1));
   EXPECT_FALSE(projector1->GetBuiltFromCache());
 
   // if the output scale/precision are same, should get a cache hit.
-  auto res_31_13_alt = field("result", arrow::decimal(31, 13));
+  auto res_31_13_alt = field("result", arrow::decimal128(31, 13));
   auto expr2 =
       TreeExprBuilder::MakeExpression("castDECIMAL", {field_float64}, res_31_13_alt);
   std::shared_ptr<Projector> projector2;
diff --git a/cpp/src/gandiva/tree_expr_builder.cc b/cpp/src/gandiva/tree_expr_builder.cc
index 82bb661ecda80..122013a1dbe9e 100644
--- a/cpp/src/gandiva/tree_expr_builder.cc
+++ b/cpp/src/gandiva/tree_expr_builder.cc
@@ -53,8 +53,8 @@ NodePtr TreeExprBuilder::MakeBinaryLiteral(const std::string& value) {
 }
 
 NodePtr TreeExprBuilder::MakeDecimalLiteral(const DecimalScalar128& value) {
-  return std::make_shared<LiteralNode>(arrow::decimal(value.precision(), value.scale()),
-                                       LiteralHolder(value), false);
+  return std::make_shared<LiteralNode>(
+      arrow::decimal128(value.precision(), value.scale()), LiteralHolder(value), false);
 }
 
 NodePtr TreeExprBuilder::MakeNull(DataTypePtr data_type) {
diff --git a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
index 5d990a5c6bd4a..73974f9b2a888 100644
--- a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
+++ b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
@@ -857,10 +857,10 @@ typedef ::testing::Types<
     ::arrow::Int16Type, ::arrow::Int32Type, ::arrow::UInt64Type, ::arrow::Int64Type,
     ::arrow::Date32Type, ::arrow::FloatType, ::arrow::DoubleType, ::arrow::StringType,
     ::arrow::BinaryType, ::arrow::FixedSizeBinaryType, ::arrow::HalfFloatType,
-    DecimalWithPrecisionAndScale<1>, DecimalWithPrecisionAndScale<5>,
-    DecimalWithPrecisionAndScale<10>, DecimalWithPrecisionAndScale<19>,
-    DecimalWithPrecisionAndScale<23>, DecimalWithPrecisionAndScale<27>,
-    DecimalWithPrecisionAndScale<38>, Decimal256WithPrecisionAndScale<39>,
+    Decimal128WithPrecisionAndScale<1>, Decimal128WithPrecisionAndScale<5>,
+    Decimal128WithPrecisionAndScale<10>, Decimal128WithPrecisionAndScale<19>,
+    Decimal128WithPrecisionAndScale<23>, Decimal128WithPrecisionAndScale<27>,
+    Decimal128WithPrecisionAndScale<38>, Decimal256WithPrecisionAndScale<39>,
     Decimal256WithPrecisionAndScale<56>, Decimal256WithPrecisionAndScale<76>>
     TestTypes;
 
@@ -4146,11 +4146,12 @@ TEST_P(TestArrowReaderAdHocSparkAndHvr, ReadDecimals) {
 INSTANTIATE_TEST_SUITE_P(
     ReadDecimals, TestArrowReaderAdHocSparkAndHvr,
     ::testing::Values(
-        std::make_tuple("int32_decimal.parquet", ::arrow::decimal(4, 2)),
-        std::make_tuple("int64_decimal.parquet", ::arrow::decimal(10, 2)),
-        std::make_tuple("fixed_length_decimal.parquet", ::arrow::decimal(25, 2)),
-        std::make_tuple("fixed_length_decimal_legacy.parquet", ::arrow::decimal(13, 2)),
-        std::make_tuple("byte_array_decimal.parquet", ::arrow::decimal(4, 2))));
+        std::make_tuple("int32_decimal.parquet", ::arrow::decimal128(4, 2)),
+        std::make_tuple("int64_decimal.parquet", ::arrow::decimal128(10, 2)),
+        std::make_tuple("fixed_length_decimal.parquet", ::arrow::decimal128(25, 2)),
+        std::make_tuple("fixed_length_decimal_legacy.parquet",
+                        ::arrow::decimal128(13, 2)),
+        std::make_tuple("byte_array_decimal.parquet", ::arrow::decimal128(4, 2))));
 
 TEST(TestArrowReaderAdHoc, ReadFloat16Files) {
   using ::arrow::util::Float16;
@@ -5095,8 +5096,8 @@ class TestIntegerAnnotateDecimalTypeParquetIO : public TestParquetIO<TestType> {
 };
 
 typedef ::testing::Types<
-    DecimalWithPrecisionAndScale<1>, DecimalWithPrecisionAndScale<5>,
-    DecimalWithPrecisionAndScale<10>, DecimalWithPrecisionAndScale<18>,
+    Decimal128WithPrecisionAndScale<1>, Decimal128WithPrecisionAndScale<5>,
+    Decimal128WithPrecisionAndScale<10>, Decimal128WithPrecisionAndScale<18>,
     Decimal256WithPrecisionAndScale<1>, Decimal256WithPrecisionAndScale<5>,
     Decimal256WithPrecisionAndScale<10>, Decimal256WithPrecisionAndScale<18>>
     DecimalTestTypes;
diff --git a/cpp/src/parquet/arrow/arrow_schema_test.cc b/cpp/src/parquet/arrow/arrow_schema_test.cc
index 31ead461aa6e2..df962badf5c85 100644
--- a/cpp/src/parquet/arrow/arrow_schema_test.cc
+++ b/cpp/src/parquet/arrow/arrow_schema_test.cc
@@ -184,11 +184,11 @@ TEST_F(TestConvertParquetSchema, ParquetAnnotatedFields) {
       {"string", LogicalType::String(), ParquetType::BYTE_ARRAY, -1, ::arrow::utf8()},
       {"enum", LogicalType::Enum(), ParquetType::BYTE_ARRAY, -1, ::arrow::binary()},
       {"decimal(8, 2)", LogicalType::Decimal(8, 2), ParquetType::INT32, -1,
-       ::arrow::decimal(8, 2)},
+       ::arrow::decimal128(8, 2)},
       {"decimal(16, 4)", LogicalType::Decimal(16, 4), ParquetType::INT64, -1,
-       ::arrow::decimal(16, 4)},
+       ::arrow::decimal128(16, 4)},
       {"decimal(32, 8)", LogicalType::Decimal(32, 8), ParquetType::FIXED_LEN_BYTE_ARRAY,
-       16, ::arrow::decimal(32, 8)},
+       16, ::arrow::decimal128(32, 8)},
       {"date", LogicalType::Date(), ParquetType::INT32, -1, ::arrow::date32()},
       {"time(ms)", LogicalType::Time(true, LogicalType::TimeUnit::MILLIS),
        ParquetType::INT32, -1, ::arrow::time32(::arrow::TimeUnit::MILLI)},
@@ -929,13 +929,13 @@ TEST_F(TestConvertArrowSchema, ArrowFields) {
       {"utf8", ::arrow::utf8(), LogicalType::String(), ParquetType::BYTE_ARRAY, -1},
       {"large_utf8", ::arrow::large_utf8(), LogicalType::String(),
        ParquetType::BYTE_ARRAY, -1},
-      {"decimal(1, 0)", ::arrow::decimal(1, 0), LogicalType::Decimal(1, 0),
+      {"decimal(1, 0)", ::arrow::decimal128(1, 0), LogicalType::Decimal(1, 0),
        ParquetType::FIXED_LEN_BYTE_ARRAY, 1},
-      {"decimal(8, 2)", ::arrow::decimal(8, 2), LogicalType::Decimal(8, 2),
+      {"decimal(8, 2)", ::arrow::decimal128(8, 2), LogicalType::Decimal(8, 2),
        ParquetType::FIXED_LEN_BYTE_ARRAY, 4},
-      {"decimal(16, 4)", ::arrow::decimal(16, 4), LogicalType::Decimal(16, 4),
+      {"decimal(16, 4)", ::arrow::decimal128(16, 4), LogicalType::Decimal(16, 4),
        ParquetType::FIXED_LEN_BYTE_ARRAY, 7},
-      {"decimal(32, 8)", ::arrow::decimal(32, 8), LogicalType::Decimal(32, 8),
+      {"decimal(32, 8)", ::arrow::decimal128(32, 8), LogicalType::Decimal(32, 8),
        ParquetType::FIXED_LEN_BYTE_ARRAY, 14},
       {"float16", ::arrow::float16(), LogicalType::Float16(),
        ParquetType::FIXED_LEN_BYTE_ARRAY, 2},
@@ -1462,7 +1462,7 @@ TEST_F(TestConvertRoundTrip, FieldIdPreserveAllColumnTypes) {
 }
 
 TEST(InvalidSchema, ParquetNegativeDecimalScale) {
-  const auto& type = ::arrow::decimal(23, -2);
+  const auto& type = ::arrow::decimal128(23, -2);
   const auto& field = ::arrow::field("f0", type);
   const auto& arrow_schema = ::arrow::schema({field});
   std::shared_ptr<::parquet::WriterProperties> properties =
diff --git a/cpp/src/parquet/arrow/test_util.h b/cpp/src/parquet/arrow/test_util.h
index b2be1b3c5354d..c8fcbbb65d1b6 100644
--- a/cpp/src/parquet/arrow/test_util.h
+++ b/cpp/src/parquet/arrow/test_util.h
@@ -48,7 +48,7 @@ using ::arrow::ChunkedArray;
 using ::arrow::Status;
 
 template <int32_t PRECISION>
-struct DecimalWithPrecisionAndScale {
+struct Decimal128WithPrecisionAndScale {
   static_assert(PRECISION >= 1 && PRECISION <= 38, "Invalid precision value");
 
   using type = ::arrow::Decimal128Type;
@@ -142,7 +142,11 @@ template <int32_t byte_width>
 static void random_decimals(int64_t n, uint32_t seed, int32_t precision, uint8_t* out) {
   auto gen = ::arrow::random::RandomArrayGenerator(seed);
   std::shared_ptr<Array> decimals;
-  if constexpr (byte_width == 16) {
+  if constexpr (byte_width == 4) {
+    decimals = gen.Decimal32(::arrow::decimal32(precision, 0), n);
+  } else if constexpr (byte_width == 8) {
+    decimals = gen.Decimal64(::arrow::decimal64(precision, 0), n);
+  } else if constexpr (byte_width == 16) {
     decimals = gen.Decimal128(::arrow::decimal128(precision, 0), n);
   } else {
     decimals = gen.Decimal256(::arrow::decimal256(precision, 0), n);
@@ -152,12 +156,12 @@ static void random_decimals(int64_t n, uint32_t seed, int32_t precision, uint8_t
 
 template <typename ArrowType, int32_t precision = ArrowType::precision>
 ::arrow::enable_if_t<
-    std::is_same<ArrowType, DecimalWithPrecisionAndScale<precision>>::value, Status>
+    std::is_same<ArrowType, Decimal128WithPrecisionAndScale<precision>>::value, Status>
 NonNullArray(size_t size, std::shared_ptr<Array>* out) {
   constexpr int32_t kDecimalPrecision = precision;
-  constexpr int32_t kDecimalScale = DecimalWithPrecisionAndScale<precision>::scale;
+  constexpr int32_t kDecimalScale = Decimal128WithPrecisionAndScale<precision>::scale;
 
-  const auto type = ::arrow::decimal(kDecimalPrecision, kDecimalScale);
+  const auto type = ::arrow::decimal128(kDecimalPrecision, kDecimalScale);
   ::arrow::Decimal128Builder builder(type);
   const int32_t byte_width =
       static_cast<const ::arrow::Decimal128Type&>(*type).byte_width();
@@ -339,7 +343,7 @@ ::arrow::enable_if_fixed_size_binary<ArrowType, Status> NullableArray(
 
 template <typename ArrowType, int32_t precision = ArrowType::precision>
 ::arrow::enable_if_t<
-    std::is_same<ArrowType, DecimalWithPrecisionAndScale<precision>>::value, Status>
+    std::is_same<ArrowType, Decimal128WithPrecisionAndScale<precision>>::value, Status>
 NullableArray(size_t size, size_t num_nulls, uint32_t seed,
               std::shared_ptr<::arrow::Array>* out) {
   std::vector<uint8_t> valid_bytes(size, '\1');
@@ -349,8 +353,8 @@ NullableArray(size_t size, size_t num_nulls, uint32_t seed,
   }
 
   constexpr int32_t kDecimalPrecision = precision;
-  constexpr int32_t kDecimalScale = DecimalWithPrecisionAndScale<precision>::scale;
-  const auto type = ::arrow::decimal(kDecimalPrecision, kDecimalScale);
+  constexpr int32_t kDecimalScale = Decimal128WithPrecisionAndScale<precision>::scale;
+  const auto type = ::arrow::decimal128(kDecimalPrecision, kDecimalScale);
   const int32_t byte_width =
       static_cast<const ::arrow::Decimal128Type&>(*type).byte_width();
 
diff --git a/dev/archery/archery/integration/datagen.py b/dev/archery/archery/integration/datagen.py
index 970fe2e16bfe9..d7f88083f4a4e 100644
--- a/dev/archery/archery/integration/datagen.py
+++ b/dev/archery/archery/integration/datagen.py
@@ -1590,6 +1590,28 @@ def generate_null_trivial_case(batch_sizes):
     return _generate_file('null_trivial', fields, batch_sizes)
 
 
+def generate_decimal32_case():
+    fields = [
+        DecimalField(name='f{}'.format(i), precision=precision, scale=2,
+                     bit_width=32)
+        for i, precision in enumerate(range(3, 10))
+    ]
+
+    batch_sizes = [7, 10]
+    return _generate_file('decimal32', fields, batch_sizes)
+
+
+def generate_decimal64_case():
+    fields = [
+        DecimalField(name='f{}'.format(i), precision=precision, scale=2,
+                     bit_width=64)
+        for i, precision in enumerate(range(3, 19))
+    ]
+
+    batch_sizes = [7, 10]
+    return _generate_file('decimal64', fields, batch_sizes)
+
+
 def generate_decimal128_case():
     fields = [
         DecimalField(name='f{}'.format(i), precision=precision, scale=2,
@@ -1883,6 +1905,22 @@ def _temp_path():
         generate_decimal256_case()
         .skip_tester('JS'),
 
+        generate_decimal32_case()
+        .skip_tester('C#')
+        .skip_tester('Java')
+        .skip_tester('JS')
+        .skip_tester('nanoarrow')
+        .skip_tester('Rust')
+        .skip_tester('Go'),
+
+        generate_decimal64_case()
+        .skip_tester('C#')
+        .skip_tester('Java')
+        .skip_tester('JS')
+        .skip_tester('nanoarrow')
+        .skip_tester('Rust')
+        .skip_tester('Go'),
+
         generate_datetime_case(),
 
         generate_duration_case(),
diff --git a/docs/source/status.rst b/docs/source/status.rst
index 765aeb1a076ae..7deb3f512c68b 100644
--- a/docs/source/status.rst
+++ b/docs/source/status.rst
@@ -44,6 +44,10 @@ Data Types
 +-------------------+-------+-------+-------+----+-------+-------+-------+-------+-----------+
 | Float32/64        | ✓     | ✓     | ✓     | ✓  |  ✓    |  ✓    | ✓     | ✓     | ✓         |
 +-------------------+-------+-------+-------+----+-------+-------+-------+-------+-----------+
+| Decimal32         | ✓     |       | ✓     |    |       |       |       |       |           |
++-------------------+-------+-------+-------+----+-------+-------+-------+-------+-----------+
+| Decimal64         | ✓     |       | ✓     |    |       |       |       |       |           |
++-------------------+-------+-------+-------+----+-------+-------+-------+-------+-----------+
 | Decimal128        | ✓     | ✓     | ✓     | ✓  |  ✓    |  ✓    | ✓     |       | ✓         |
 +-------------------+-------+-------+-------+----+-------+-------+-------+-------+-----------+
 | Decimal256        | ✓     | ✓     | ✓     | ✓  |  ✓    |  ✓    | ✓     |       | ✓         |
diff --git a/python/pyarrow/src/arrow/python/arrow_to_pandas.cc b/python/pyarrow/src/arrow/python/arrow_to_pandas.cc
index 734f6263d9990..110dab7d35538 100644
--- a/python/pyarrow/src/arrow/python/arrow_to_pandas.cc
+++ b/python/pyarrow/src/arrow/python/arrow_to_pandas.cc
@@ -1317,6 +1317,14 @@ struct ObjectWriterVisitor {
                                                         out_values);
   }
 
+  Status Visit(const Decimal32Type& type) {
+    return Status::NotImplemented("Decimal32 type not yet implemented");
+  }
+
+  Status Visit(const Decimal64Type& type) {
+    return Status::NotImplemented("Decimal64 type not yet implemented");
+  }
+
   Status Visit(const Decimal128Type& type) {
     OwnedRef decimal;
     OwnedRef Decimal;