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..fe4dc5e2223e9 100644
--- a/cpp/src/arrow/array/array_base.cc
+++ b/cpp/src/arrow/array/array_base.cc
@@ -74,6 +74,14 @@ 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 32806d9d2edb3..b5e89e4ad9e48 100644
--- a/cpp/src/arrow/array/array_test.cc
+++ b/cpp/src/arrow/array/array_test.cc
@@ -667,7 +667,9 @@ 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<Decimal32Scalar>(Decimal32(10), decimal(7, 4)),
+      std::make_shared<Decimal64Scalar>(Decimal64(10), decimal(12, 4)),
+      std::make_shared<Decimal128Scalar>(Decimal128(10), decimal(20, 4)),
       std::make_shared<Decimal256Scalar>(Decimal256(10), decimal(76, 38)),
       std::make_shared<StringScalar>(hello),
       std::make_shared<LargeStringScalar>(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.234234"));
+  draw.push_back(big);
+
+  Decimal32 big_negative;
+  ASSERT_OK_AND_ASSIGN(big_negative, Decimal32::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(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..280690d5b51fe 100644
--- a/cpp/src/arrow/array/array_view_test.cc
+++ b/cpp/src/arrow/array/array_view_test.cc
@@ -385,10 +385,34 @@ TEST(TestArrayView, SparseUnionAsStruct) {
   CheckView(expected, arr);
 }
 
-TEST(TestArrayView, DecimalRoundTrip) {
+TEST(TestArrayView, Decimal32RoundTrip) {
+  auto ty1 = decimal(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 = decimal(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 = decimal(20, 4);
+  auto arr = ArrayFromJSON(ty1, R"(["123.4567", "-78.9000", null])");
+
   auto ty2 = fixed_size_binary(16);
   ASSERT_OK_AND_ASSIGN(auto v, arr->View(ty2));
   ASSERT_OK(v->ValidateFull());
@@ -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..e4d67d5f1769f 100644
--- a/cpp/src/arrow/array/builder_decimal.cc
+++ b/cpp/src/arrow/array/builder_decimal.cc
@@ -32,6 +32,77 @@ 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..c506a78b05276 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..2b6df0cabeab9 100644
--- a/cpp/src/arrow/array/builder_dict.h
+++ b/cpp/src/arrow/array/builder_dict.h
@@ -298,6 +298,22 @@ class DictionaryBuilderBase : public ArrayBuilder {
     return Append(std::string_view(value, length));
   }
 
+  /// \brief Append a decimal (only for Decimal32Type)
+  template <typename T1 = T>
+  enable_if_decimal32<T1, Status> Append(const Decimal32& value) {
+    uint8_t data[4];
+    value.ToBytes(data);
+    return Append(data, 4);
+  }
+
+  /// \brief Append a decimal (only for Decimal64Type)
+  template <typename T1 = T>
+  enable_if_decimal64<T1, Status> Append(const Decimal64& value) {
+    uint8_t data[8];
+    value.ToBytes(data);
+    return Append(data, 8);
+  }
+
   /// \brief Append a decimal (only for Decimal128Type)
   template <typename T1 = T>
   enable_if_decimal128<T1, Status> Append(const Decimal128& value) {
@@ -306,7 +322,7 @@ class DictionaryBuilderBase : public ArrayBuilder {
     return Append(data, 16);
   }
 
-  /// \brief Append a decimal (only for Decimal128Type)
+  /// \brief Append a decimal (only for Decimal256Type)
   template <typename T1 = T>
   enable_if_decimal256<T1, Status> Append(const Decimal256& value) {
     uint8_t data[32];
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..26fc854af89d3 100644
--- a/cpp/src/arrow/array/diff.cc
+++ b/cpp/src/arrow/array/diff.cc
@@ -707,7 +707,11 @@ 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) {
+      if constexpr (T::type_id == Type::DECIMAL32) {
+        *os << checked_cast<const Decimal32Array&>(array).FormatValue(index);
+      } else if constexpr (T::type_id == Type::DECIMAL64) {
+        *os << checked_cast<const Decimal64Array&>(array).FormatValue(index);
+      } else if constexpr (T::type_id == Type::DECIMAL128) {
         *os << checked_cast<const Decimal128Array&>(array).FormatValue(index);
       } else {
         *os << checked_cast<const Decimal256Array&>(array).FormatValue(index);
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..d468a8db5fe0c 100644
--- a/cpp/src/arrow/array/util.cc
+++ b/cpp/src/arrow/array/util.cc
@@ -152,6 +152,42 @@ class ArrayDataEndianSwapper {
     return Status::OK();
   }
 
+  Status Visit(const Decimal32Type& type) {
+    auto data = reinterpret_cast<const uint32_t*>(data_->buffers[1]->data());
+    ARROW_ASSIGN_OR_RAISE(auto new_buffer,
+                          AllocateBuffer(data_->buffers[1]->size(), pool_));
+    auto new_data = reinterpret_cast<uint32_t*>(new_buffer->mutable_data());
+    // NOTE: data_->length not trusted (see warning above)
+    const int64_t length = data_->buffers[1]->size() / Decimal32Type::kByteWidth;
+    for (int64_t i = 0; i < length; i++) {
+#if ARROW_LITTLE_ENDIAN
+      new_data[i] = bit_util::FromBigEndian(data[i]);
+#else
+      new_data[i] = bit_util::FromLittleEndian(data[i]);
+#endif
+    }
+    out_->buffers[1] = std::move(new_buffer);
+    return Status::OK();
+  }
+
+  Status Visit(const Decimal64Type& type) {
+    auto data = reinterpret_cast<const uint64_t*>(data_->buffers[1]->data());
+    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() / Decimal64Type::kByteWidth;
+    for (int64_t i = 0; i < length; i++) {
+#if ARROW_LITTLE_ENDIAN
+      new_data[i] = bit_util::FromBigEndian(data[i]);
+#else
+      new_data[i] = bit_util::FromLittleEndian(data[i]);
+#endif
+    }
+    out_->buffers[1] = std::move(new_buffer);
+    return Status::OK();
+  }
+
   Status Visit(const Decimal128Type& type) {
     auto data = reinterpret_cast<const uint64_t*>(data_->buffers[1]->data());
     ARROW_ASSIGN_OR_RAISE(auto new_buffer,
diff --git a/cpp/src/arrow/array/validate.cc b/cpp/src/arrow/array/validate.cc
index 0d940d3bc869e..4cce2b76c2fc9 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/c/bridge.cc b/cpp/src/arrow/c/bridge.cc
index eba575f4cf39c..9deac40bcb0d8 100644
--- a/cpp/src/arrow/c/bridge.cc
+++ b/cpp/src/arrow/c/bridge.cc
@@ -1253,6 +1253,10 @@ struct SchemaImporter {
       type_ = decimal128(prec_scale[0], prec_scale[1]);
     } else if (prec_scale[2] == 256) {
       type_ = decimal256(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 {
       return f_parser_.Invalid();
     }
diff --git a/cpp/src/arrow/c/bridge_test.cc b/cpp/src/arrow/c/bridge_test.cc
index 09bb524adbdf0..d0a79104c14a2 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(decimal(8, 4), "d:8,4,32");
+  TestPrimitive(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(decimal(8, 0), "d:8,0,32");
+  TestPrimitive(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(decimal(8, -4), "d:8,-4,32");
+  TestPrimitive(decimal(15, -4), "d:15,-4,64");
+  TestPrimitive(decimal128(15, -4), "d:15,-4");
   TestPrimitive(decimal256(15, -4), "d:15,-4,256");
 }
 
@@ -1951,6 +1957,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 +1968,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 +1979,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 +2052,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 +2968,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 +3642,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); });
@@ -3901,6 +3925,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 +3934,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..4feda085e56f2 100644
--- a/cpp/src/arrow/compare.cc
+++ b/cpp/src/arrow/compare.cc
@@ -750,6 +750,18 @@ class TypeEqualsVisitor {
     return Status::OK();
   }
 
+  Status Visit(const Decimal32Type& left) {
+    const auto& right = checked_cast<const Decimal32Type&>(right_);
+    result_ = left.precision() == right.precision() && left.scale() == right.scale();
+    return Status::OK();
+  }
+
+  Status Visit(const Decimal64Type& left) {
+    const auto& right = checked_cast<const Decimal64Type&>(right_);
+    result_ = left.precision() == right.precision() && left.scale() == right.scale();
+    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();
@@ -900,6 +912,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..21b2338e59329 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(*decimal(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
@@ -203,7 +203,7 @@ TEST(InputType, Matches) {
   ASSERT_TRUE(input1.Matches(*int8()));
   ASSERT_FALSE(input1.Matches(*int16()));
 
-  InputType input2(Type::DECIMAL);
+  InputType input2(Type::DECIMAL64);
   ASSERT_TRUE(input2.Matches(*decimal(12, 2)));
 
   auto ty2 = decimal(12, 2);
@@ -312,7 +312,7 @@ TEST(OutputType, Resolve) {
 
 TEST(KernelSignature, Basics) {
   // (int8, decimal) -> utf8
-  std::vector<InputType> in_types({int8(), InputType(Type::DECIMAL)});
+  std::vector<InputType> in_types({int8(), InputType(Type::DECIMAL64)});
   OutputType out_type(utf8());
 
   KernelSignature sig(in_types, out_type);
@@ -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 1fbcd6a249093..ae6069e190f8c 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -1042,7 +1042,7 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
 
   func = std::make_shared<ScalarAggregateFunction>("sum", Arity::Unary(), sum_doc,
                                                    &default_scalar_aggregate_options);
-  AddArrayScalarAggKernels(SumInit, {boolean()}, uint64(), func.get());
+  AddArrayScalarAggKernels(SumInit, {boolean()}, uint64(), func.get());  
   AddAggKernel(KernelSignature::Make({Type::DECIMAL128}, FirstType), SumInit, func.get(),
                SimdLevel::NONE);
   AddAggKernel(KernelSignature::Make({Type::DECIMAL256}, FirstType), SumInit, func.get(),
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_mode.cc b/cpp/src/arrow/compute/kernels/aggregate_mode.cc
index 3f84c0a5ee4c4..86b20674b85ec 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_mode.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_mode.cc
@@ -454,7 +454,7 @@ VectorKernel NewModeKernel(const std::shared_ptr<DataType>& in_type, ArrayKernel
   kernel.init = ModeState::Init;
   kernel.can_execute_chunkwise = false;
   kernel.output_chunked = false;
-  switch (in_type->id()) {
+  switch (in_type->id()) {    
     case Type::DECIMAL128:
     case Type::DECIMAL256:
       kernel.signature =
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..28a98ee960d78 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,7 +55,7 @@ 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(
+  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();
diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index 9e46a21887f8c..7bfdb92611cd4 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -140,6 +140,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;
@@ -177,6 +201,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;
@@ -224,7 +258,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>;
 
 // ----------------------------------------------------------------------
@@ -353,6 +389,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;
@@ -1116,6 +1168,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:
@@ -1295,6 +1351,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 4bf6a6106dfe5..6943599cd1a51 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate.cc
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
@@ -619,7 +619,7 @@ struct GroupedReducingFactory {
   Status Visit(const T&) {
     kernel = MakeKernel(std::move(argument_type), HashAggregateInit<Impl<T>>);
     return Status::OK();
-  }
+  }  
 
   Status Visit(const Decimal128Type&) {
     kernel =
@@ -880,6 +880,12 @@ 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,7 +898,7 @@ 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(
+  enable_if_t<is_floating_type<T>::value || (sizeof(CType) > 4) || (!is_integer_type<T>::value && sizeof(CType) == 4), Status> ConsumeImpl(
       const ExecSpan& batch) {
     using SumType = typename internal::GetSumType<T>::SumType;
 
@@ -1186,6 +1192,12 @@ 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 +1377,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..25b77c71e9115 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});
 }
 
@@ -631,14 +631,14 @@ TEST_F(TestHashKernel, ValueCountsDecimal) {
   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});
+      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..77eddd9ff70af 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), decimal(70, 10)};
 
     test_input_types_.insert(test_input_types_.end(), test_numerical_types_.begin(),
                              test_numerical_types_.end());
@@ -188,8 +188,8 @@ 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);
   }
 
diff --git a/cpp/src/arrow/csv/converter_test.cc b/cpp/src/arrow/csv/converter_test.cc
index 657e8d813ca1b..6ae25fe5fdbd3 100644
--- a/cpp/src/arrow/csv/converter_test.cc
+++ b/cpp/src/arrow/csv/converter_test.cc
@@ -676,26 +676,26 @@ TEST(DecimalConversion, Basics) {
 
 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..f49ed10bb0086 100644
--- a/cpp/src/arrow/engine/substrait/expression_internal.cc
+++ b/cpp/src/arrow/engine/substrait/expression_internal.cc
@@ -951,6 +951,38 @@ struct ScalarToProtoImpl {
   Status Visit(const MonthIntervalScalar& s) { return NotImplemented(s); }
   Status Visit(const DayTimeIntervalScalar& s) { return NotImplemented(s); }
 
+  Status Visit(const Decimal32Scalar& s) {
+    auto decimal = std::make_unique<Lit::Decimal>();
+
+    auto decimal_type = checked_cast<const Decimal32Type*>(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(Decimal32));
+#if !ARROW_LITTLE_ENDIAN
+    std::reverse(decimal->mutable_value()->begin(), decimal->mutable_value()->end());
+#endif
+    lit_->set_allocated_decimal(decimal.release());
+    return Status::OK();
+  }
+
+  Status Visit(const Decimal64Scalar& s) {
+    auto decimal = std::make_unique<Lit::Decimal>();
+
+    auto decimal_type = checked_cast<const Decimal64Type*>(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(Decimal64));
+#if !ARROW_LITTLE_ENDIAN
+    std::reverse(decimal->mutable_value()->begin(), decimal->mutable_value()->end());
+#endif
+    lit_->set_allocated_decimal(decimal.release());
+    return Status::OK();
+  }
+
   Status Visit(const Decimal128Scalar& s) {
     auto decimal = std::make_unique<Lit::Decimal>();
 
diff --git a/cpp/src/arrow/integration/json_internal.cc b/cpp/src/arrow/integration/json_internal.cc
index 89719b4ba4b2e..5f87f282a55d3 100644
--- a/cpp/src/arrow/integration/json_internal.cc
+++ b/cpp/src/arrow/integration/json_internal.cc
@@ -314,6 +314,20 @@ class SchemaWriter {
     writer_->Int(type.list_size());
   }
 
+  void WriteTypeMetadata(const Decimal32Type& type) {
+    writer_->Key("precision");
+    writer_->Int(type.precision());
+    writer_->Key("scale");
+    writer_->Int(type.scale());
+  }
+
+  void WriteTypeMetadata(const Decimal64Type& type) {
+    writer_->Key("precision");
+    writer_->Int(type.precision());
+    writer_->Key("scale");
+    writer_->Int(type.scale());
+  }
+
   void WriteTypeMetadata(const Decimal128Type& type) {
     writer_->Key("precision");
     writer_->Int(type.precision());
@@ -399,6 +413,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 +611,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,11 +1009,17 @@ 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",
                          bit_width);
 }
diff --git a/cpp/src/arrow/ipc/json_simple.cc b/cpp/src/arrow/ipc/json_simple.cc
index 9fd449831c980..3ce344170562c 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>
@@ -885,7 +889,9 @@ Status GetDictConverter(const std::shared_ptr<DataType>& type,
     PARAM_CONVERTER_CASE(Type::STRING_VIEW, StringConverter, StringViewType)
     PARAM_CONVERTER_CASE(Type::BINARY_VIEW, StringConverter, BinaryViewType)
     SIMPLE_CONVERTER_CASE(Type::FIXED_SIZE_BINARY, FixedSizeBinaryConverter,
-                          FixedSizeBinaryType)
+                          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:
@@ -947,7 +953,9 @@ Status GetConverter(const std::shared_ptr<DataType>& type,
     SIMPLE_CONVERTER_CASE(Type::LARGE_BINARY, StringConverter<LargeBinaryType>)
     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::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 c6f14b1e1d50e..f178a9ea9a67f 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..3b22492f18c65 100644
--- a/cpp/src/arrow/ipc/metadata_internal.cc
+++ b/cpp/src/arrow/ipc/metadata_internal.cc
@@ -278,13 +278,20 @@ 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 supports 32-bit, 64-bit, 128-bit or 256-bit decimal values");
     }
     case flatbuf::Type::Date: {
       auto date_type = static_cast<const flatbuf::Date*>(type_data);
@@ -650,6 +657,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/json/converter.cc b/cpp/src/arrow/json/converter.cc
index c393b77acf334..d68adca8d08e3 100644
--- a/cpp/src/arrow/json/converter.cc
+++ b/cpp/src/arrow/json/converter.cc
@@ -305,7 +305,9 @@ Status MakeConverter(const std::shared_ptr<DataType>& out_type, MemoryPool* pool
     CONVERTER_CASE(Type::LARGE_BINARY, BinaryConverter<LargeBinaryType>);
     CONVERTER_CASE(Type::LARGE_STRING, BinaryConverter<LargeStringType>);
     CONVERTER_CASE(Type::BINARY_VIEW, BinaryConverter<BinaryViewType>);
-    CONVERTER_CASE(Type::STRING_VIEW, BinaryConverter<StringViewType>);
+    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/pretty_print_test.cc b/cpp/src/arrow/pretty_print_test.cc
index 5d2256e8c5d44..caa134f6d5052 100644
--- a/cpp/src/arrow/pretty_print_test.cc
+++ b/cpp/src/arrow/pretty_print_test.cc
@@ -1106,10 +1106,10 @@ 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/testing/gtest_util.h b/cpp/src/arrow/testing/gtest_util.h
index 85b4c1f1f0138..f729aba0b7760 100644
--- a/cpp/src/arrow/testing/gtest_util.h
+++ b/cpp/src/arrow/testing/gtest_util.h
@@ -171,7 +171,8 @@ using PrimitiveArrowTypes =
 using TemporalArrowTypes =
     ::testing::Types<Date32Type, Date64Type, TimestampType, Time32Type, Time64Type>;
 
-using DecimalArrowTypes = ::testing::Types<Decimal128Type, Decimal256Type>;
+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..e665767a6eca7 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,119 @@ struct DecimalGenerator {
   }
 };
 
+template <>
+struct DecimalGenerator<Decimal32Type> {
+  using DecimalBuilderType = typename TypeTraits<Decimal32Type>::BuilderType;
+  using DecimalValue = typename DecimalBuilderType::ValueType;
+
+  std::shared_ptr<DataType> type_;
+  RandomArrayGenerator* rng_;
+
+  static int64_t MaxDecimalInteger(int32_t digits) {
+    return static_cast<int64_t>(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 = 9;
+    static constexpr int kNumIntegers = Decimal32Type::kByteWidth / 4;
+    static_assert(
+        kNumIntegers == (Decimal32Type::kMaxPrecision + kMaxDigitsInInteger - 1) /
+                            (kMaxDigitsInInteger + 1),
+        "inconsistent decimal metadata: kMaxPrecision doesn't match kByteWidth");
+
+    // First generate separate random values for individual components:
+    // boolean sign (including null-ness), and uint64 "digits" in big endian order.
+    const auto& decimal_type = checked_cast<const DecimalType&>(*type_);
+
+    auto remaining_digits = decimal_type.precision();
+    auto values = checked_pointer_cast<Int32Array>(rng_->Int32(
+        size, -1 * MaxDecimalInteger(remaining_digits),
+        MaxDecimalInteger(remaining_digits), null_probability, alignment, memory_pool));
+
+    DecimalBuilderType builder(type_, memory_pool, alignment);
+    ABORT_NOT_OK(builder.Reserve(size));
+
+    for (int64_t i = 0; i < size; ++i) {
+      if (values->IsValid(i)) {
+        builder.UnsafeAppend(DecimalValue{values->Value(i)});
+      } else {
+        builder.UnsafeAppendNull();
+      }
+    }
+    std::shared_ptr<Array> array;
+    ABORT_NOT_OK(builder.Finish(&array));
+    return array;
+  }
+};
+
+template <>
+struct DecimalGenerator<Decimal64Type> {
+  using DecimalBuilderType = typename TypeTraits<Decimal64Type>::BuilderType;
+  using DecimalValue = typename DecimalBuilderType::ValueType;
+
+  std::shared_ptr<DataType> type_;
+  RandomArrayGenerator* rng_;
+
+  static int64_t MaxDecimalInteger(int32_t digits) {
+    return static_cast<int64_t>(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 = 18;
+    static constexpr int kNumIntegers = Decimal64Type::kByteWidth / 8;
+
+    static_assert(
+        kNumIntegers == (Decimal64Type::kMaxPrecision + kMaxDigitsInInteger - 1) /
+                            (kMaxDigitsInInteger + 1),
+        "inconsistent decimal metadata: kMaxPrecision doesn't match kByteWidth");
+
+    // First generate separate random values for individual components:
+    // boolean sign (including null-ness), and uint64 "digits" in big endian order.
+    const auto& decimal_type = checked_cast<const DecimalType&>(*type_);
+
+    auto remaining_digits = decimal_type.precision();
+    auto values = checked_pointer_cast<Int64Array>(rng_->Int64(
+        size, -1 * MaxDecimalInteger(remaining_digits),
+        MaxDecimalInteger(remaining_digits), null_probability, alignment, memory_pool));
+
+    DecimalBuilderType builder(type_, memory_pool, alignment);
+    ABORT_NOT_OK(builder.Reserve(size));
+
+    for (int64_t i = 0; i < size; ++i) {
+      if (values->IsValid(i)) {
+        builder.UnsafeAppend(DecimalValue{values->Value(i)});
+      } else {
+        builder.UnsafeAppendNull();
+      }
+    }
+    std::shared_ptr<Array> array;
+    ABORT_NOT_OK(builder.Finish(&array));
+    return array;
+  }
+};
+
 }  // namespace
 
+std::shared_ptr<Array> RandomArrayGenerator::Decimal32(std::shared_ptr<DataType> type,
+                                                       int64_t size,
+                                                       double null_probability,
+                                                       int64_t alignment,
+                                                       MemoryPool* memory_pool) {
+  DecimalGenerator<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) {
+  DecimalGenerator<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 +1186,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..256e846af0740 100644
--- a/cpp/src/arrow/testing/random.h
+++ b/cpp/src/arrow/testing/random.h
@@ -297,6 +297,37 @@ 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..3be0fae72e7f2 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)),
@@ -261,7 +262,7 @@ TYPED_TEST(RandomNumericArrayTest, EmptyRange) {
 
 template <typename DecimalType>
 class RandomDecimalArrayTest : public ::testing::Test {
- protected:
+ protected:  
   using ArrayType = typename TypeTraits<DecimalType>::ArrayType;
   using DecimalValue = typename TypeTraits<DecimalType>::BuilderType::ValueType;
 
@@ -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 91a0d87cb8ae7..cdaad4a0ebcf7 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,13 +1442,19 @@ 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);
   }
+
 }
 
 // Taken from the Apache Impala codebase. The comments next
@@ -1459,6 +1479,42 @@ int32_t DecimalType::DecimalSize(int32_t precision) {
   return static_cast<int32_t>(std::ceil((precision / 8.0) * std::log2(10) + 1));
 }
 
+// ----------------------------------------------------------------------
+// Decimal32 type
+
+Decimal32Type::Decimal32Type(int32_t precision, int32_t scale)
+    : DecimalType(type_id, 4, precision, scale) {
+  ARROW_CHECK_GE(precision, kMinPrecision);
+  ARROW_CHECK_LE(precision, kMaxPrecision);
+}
+
+Result<std::shared_ptr<DataType>> Decimal32Type::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 std::make_shared<Decimal32Type>(precision, scale);
+}
+
+// ----------------------------------------------------------------------
+// Decimal64 type
+
+Decimal64Type::Decimal64Type(int32_t precision, int32_t scale)
+    : DecimalType(type_id, 8, precision, scale) {
+  ARROW_CHECK_GE(precision, kMinPrecision);
+  ARROW_CHECK_LE(precision, kMaxPrecision);
+}
+
+Result<std::shared_ptr<DataType>> Decimal64Type::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 std::make_shared<Decimal64Type>(precision, scale);
+}
+
 // ----------------------------------------------------------------------
 // Decimal128 type
 
@@ -3301,8 +3357,18 @@ std::shared_ptr<Field> field(std::string name, std::shared_ptr<DataType> type,
 }
 
 std::shared_ptr<DataType> decimal(int32_t precision, int32_t scale) {
-  return precision <= Decimal128Type::kMaxPrecision ? decimal128(precision, scale)
-                                                    : decimal256(precision, 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) {
@@ -3313,6 +3379,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 e087c8ca1c387..3eab45aeaaeda 100644
--- a/cpp/src/arrow/type.h
+++ b/cpp/src/arrow/type.h
@@ -1024,6 +1024,77 @@ 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_fwd.h b/cpp/src/arrow/type_fwd.h
index 08777d247edbf..dc9bb99e18089 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
   };
@@ -515,6 +531,14 @@ std::shared_ptr<DataType> fixed_size_binary(int32_t byte_width);
 ARROW_EXPORT
 std::shared_ptr<DataType> 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 df484a8fc2c59..0a6491528c477 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);
diff --git a/cpp/src/arrow/type_traits.cc b/cpp/src/arrow/type_traits.cc
index ded54aff463c1..40d7eb48489b4 100644
--- a/cpp/src/arrow/type_traits.cc
+++ b/cpp/src/arrow/type_traits.cc
@@ -72,10 +72,12 @@ 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 BasicDecimal* which requires alignment of 4
       return 4;
     case Type::INT64:
     case Type::UINT64:
     case Type::DOUBLE:
+    case Type::DECIMAL64:        // May be cast to BasicDecimal* 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
diff --git a/cpp/src/arrow/type_traits.h b/cpp/src/arrow/type_traits.h
index 8caf4400fe86d..9a55e37f44fb1 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;
@@ -1278,6 +1312,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:
@@ -1460,6 +1496,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..555b1c9f6363b 100644
--- a/cpp/src/arrow/util/basic_decimal.cc
+++ b/cpp/src/arrow/util/basic_decimal.cc
@@ -50,6 +50,401 @@ static constexpr uint64_t kInt64Mask = 0xFFFFFFFFFFFFFFFF;
 static constexpr uint64_t kInt32Mask = 0xFFFFFFFF;
 #endif
 
+BasicDecimal32& BasicDecimal32::Negate() {
+  value_ = -value_;
+  return *this;
+}
+
+BasicDecimal32& BasicDecimal32::Abs() { return *this < 0 ? Negate() : *this; }
+
+BasicDecimal32 BasicDecimal32::Abs(const BasicDecimal32& in) {
+  BasicDecimal32 result(in);
+  return result.Abs();
+}
+
+BasicDecimal32& BasicDecimal32::operator+=(const BasicDecimal32& right) {
+  value_ += right.value_;
+  return *this;
+}
+
+BasicDecimal32& BasicDecimal32::operator-=(const BasicDecimal32& right) {
+  value_ -= right.value_;
+  return *this;
+}
+
+BasicDecimal32& BasicDecimal32::operator*=(const BasicDecimal32& right) {
+  value_ *= right.value_;
+  return *this;
+}
+
+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/=(const BasicDecimal32& right) {
+  value_ /= right.value_;
+  return *this;
+}
+
+BasicDecimal32& BasicDecimal32::operator|=(const BasicDecimal32& right) {
+  value_ |= right.value_;
+  return *this;
+}
+
+BasicDecimal32& BasicDecimal32::operator&=(const BasicDecimal32& right) {
+  value_ &= right.value_;
+  return *this;
+}
+
+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];
+}
+
+BasicDecimal64& BasicDecimal64::Negate() {
+  value_ = -value_;
+  return *this;
+}
+
+BasicDecimal64& BasicDecimal64::Abs() { return *this < 0 ? Negate() : *this; }
+
+BasicDecimal64 BasicDecimal64::Abs(const BasicDecimal64& in) {
+  BasicDecimal64 result(in);
+  return result.Abs();
+}
+
+BasicDecimal64& BasicDecimal64::operator+=(const BasicDecimal64& right) {
+  value_ += right.value_;
+  return *this;
+}
+
+BasicDecimal64& BasicDecimal64::operator-=(const BasicDecimal64& right) {
+  value_ -= right.value_;
+  return *this;
+}
+
+BasicDecimal64& BasicDecimal64::operator*=(const BasicDecimal64& right) {
+  value_ *= right.value_;
+  return *this;
+}
+
+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/=(const BasicDecimal64& right) {
+  value_ /= right.value_;
+  return *this;
+}
+
+BasicDecimal64& BasicDecimal64::operator|=(const BasicDecimal64& right) {
+  value_ |= right.value_;
+  return *this;
+}
+
+BasicDecimal64& BasicDecimal64::operator&=(const BasicDecimal64& right) {
+  value_ &= right.value_;
+  return *this;
+}
+
+BasicDecimal64& BasicDecimal64::operator<<=(uint32_t bits) {
+  if (bits != 0) {
+    if (bits < 32) {
+      value_ = SafeLeftShift(value_, bits);
+    } else {
+      value_ = 0;
+    }
+  }
+  return *this;
+}
+
+BasicDecimal64& BasicDecimal64::operator>>=(uint32_t bits) {
+  if (bits != 0) {
+    if (bits < 32) {
+      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& 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& 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 BasicDecimal<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 +1129,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 +1455,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 BasicDecimal<int32_t>;
+template class BasicDecimal<int64_t>;
 
 }  // namespace arrow
diff --git a/cpp/src/arrow/util/basic_decimal.h b/cpp/src/arrow/util/basic_decimal.h
index d8a91ea76b390..e3274eb027cbf 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,313 @@ class ARROW_EXPORT GenericBasicDecimal {
   }
 };
 
+template <typename BaseType>
+class ARROW_EXPORT BasicDecimal {
+ public:
+  static_assert(
+      std::is_same_v<BaseType, int32_t> || std::is_same_v<BaseType, int64_t>,
+      "for bitwidths larger than 64 bits use BasicDecimal128 and BasicDecimal256");
+
+  static constexpr int kMaxPrecision = std::numeric_limits<BaseType>::digits10;
+  static constexpr int kMaxScale = kMaxPrecision;
+  static constexpr int kBitWidth = sizeof(BaseType) * CHAR_BIT;
+  static constexpr int kByteWidth = sizeof(BaseType);
+
+  /// \brief Empty constructor creates a decimal with a value of 0.
+  constexpr BasicDecimal() 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 BasicDecimal(T value) noexcept  // NOLINT(runtime/explicit)
+      : value_(value) {}
+
+  /// \brief Create a decimal from an array of bytes.
+  ///
+  /// Bytes are assumed to be in native-endian byte order.
+  explicit BasicDecimal(const uint8_t* bytes) { memcpy(&value_, bytes, sizeof(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_ >> (sizeof(kBitWidth) - 1)); }
+
+  bool IsNegative() const { return value_ < 0; }
+
+  explicit operator bool() const { return value_ != 0; }
+
+  friend bool operator==(const BasicDecimal& left, const BasicDecimal& right) {
+    return left.value_ == right.value_;
+  }
+
+  friend bool operator!=(const BasicDecimal& left, const BasicDecimal& right) {
+    return left.value_ != right.value_;
+  }
+
+  BaseType value() const { return value_; }
+
+  /// \brief count hte number of leading binary zeroes.
+  int32_t CountLeadingBinaryZeros() const;
+
+  constexpr uint64_t low_bits() const { return static_cast<uint64_t>(value_); }
+
+ protected:
+  BaseType value_;
+};
+
+class ARROW_EXPORT BasicDecimal32 : public BasicDecimal<int32_t> {
+ public:
+  using BasicDecimal<int32_t>::BasicDecimal;
+  using ValueType = int32_t;
+
+  /// \brief Negate the current value (in-place)
+  BasicDecimal32& Negate();
+  /// \brief Absolute value (in-place)
+  BasicDecimal32& Abs();
+  /// \brief Absolute value
+  static BasicDecimal32 Abs(const BasicDecimal32& left);
+  /// \brief Add a number to this one. The result is truncated to 32 bits.
+  BasicDecimal32& operator+=(const BasicDecimal32& right);
+  /// \brief Subtract a number from this one. The result is truncated to 32 bits.
+  BasicDecimal32& operator-=(const BasicDecimal32& right);
+  /// \brief Multiply this number by another. The result is truncated to 32 bits.
+  BasicDecimal32& operator*=(const BasicDecimal32& right);
+
+  /// \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);
+  /// \brief Bitwise "or" between two BasicDecimal32s
+  BasicDecimal32& operator|=(const BasicDecimal32& right);
+  /// \brief Bitwise "and" between two BasicDecimal32s
+  BasicDecimal32& operator&=(const BasicDecimal32& right);
+  /// \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);
+};
+
+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& 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 BasicDecimal64 : public BasicDecimal<int64_t> {
+ public:
+  using BasicDecimal<int64_t>::BasicDecimal;
+  using ValueType = int64_t;
+
+  /// \brief Negate the current value (in-place)
+  BasicDecimal64& Negate();
+  /// \brief Absolute value (in-place)
+  BasicDecimal64& Abs();
+  /// \brief Absolute value
+  static BasicDecimal64 Abs(const BasicDecimal64& left);
+  /// \brief Add a number to this one. The result is truncated to 32 bits.
+  BasicDecimal64& operator+=(const BasicDecimal64& right);
+  /// \brief Subtract a number from this one. The result is truncated to 32 bits.
+  BasicDecimal64& operator-=(const BasicDecimal64& right);
+  /// \brief Multiply this number by another. The result is truncated to 32 bits.
+  BasicDecimal64& operator*=(const BasicDecimal64& right);
+
+  /// \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);
+  /// \brief Bitwise "or" between two BasicDecimal64s
+  BasicDecimal64& operator|=(const BasicDecimal64& right);
+  /// \brief Bitwise "and" between two BasicDecimal64s
+  BasicDecimal64& operator&=(const BasicDecimal64& right);
+  /// \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);
+};
+
+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& 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);
+
 /// 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..dc83610c39bcd 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;
 
@@ -237,6 +238,140 @@ 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) {
+    if (bits == 0) {
+      return x;
+    }
+
+    int32_t result = x.value();
+    uint32_t shifted = 0;
+    if (bits > 0) {
+      shifted = (result << (32 - bits));
+      result >>= bits;
+    }
+    constexpr uint32_t kHalf = 0x80000000;
+    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 Decimal32(result);
+  }
+
+  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;
+    }
+
+    int32_t result = x.value();
+    uint32_t shifted = 0;
+    if (bits > 0) {
+      shifted = (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 +477,54 @@ 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 { return std::to_string(value_); }
+
+Decimal32::operator int64_t() const { return 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 { return std::to_string(value_); }
+
+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 +695,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>";
@@ -521,6 +724,23 @@ std::string Decimal128::ToString(int32_t scale) const {
   return str;
 }
 
+static inline void ShiftAndAdd(std::string_view input, uint32_t* out) {
+  for (size_t posn = 0; posn < input.size();) {
+    const size_t group_size = std::min(kInt32DecimalDigits, input.size() - posn);
+    const uint32_t multiple = kUInt32PowersOfTen[group_size];
+    uint32_t chunk = 0;
+    ARROW_CHECK(
+        internal::ParseValue<UInt32Type>(input.data() + posn, group_size, &chunk));
+
+    uint64_t tmp = *out;
+    tmp *= multiple;
+    tmp += chunk;
+
+    *out = static_cast<uint32_t>(tmp & 0xFFFFFFFFU);
+    posn += group_size;
+  }
+}
+
 // Iterates over input and for each group of kInt64DecimalDigits multiple out by
 // the appropriate power of 10 necessary to add source parsed as uint64 and
 // then adds the parsed value of source.
@@ -697,8 +917,148 @@ 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) {
+    if constexpr (std::is_same_v<Decimal32, DecimalClass>) {
+      uint32_t value{0};
+      ShiftAndAdd(dec.whole_digits, &value);
+      ShiftAndAdd(dec.fractional_digits, &value);
+      if (value > 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();
+      }
+    } else {
+      uint64_t value{0};
+      ShiftAndAdd(dec.whole_digits, &value, 1);
+      ShiftAndAdd(dec.fractional_digits, &value, 1);
+      if (value > 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 +1102,78 @@ 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;
+
+  uint32_t result = 0;
+  memcpy(reinterpret_cast<uint8_t*>(&result) + kMaxDecimalBytes - length, bytes, length);
+
+  const auto value = bit_util::FromBigEndian(result);
+  const int32_t bits_offset = std::max(0, length - kMaxDecimalBytes);
+  if (bits_offset == 8) {
+    return Decimal32(value);
+  }
+
+  int32_t final_value = -1 * (is_negative && length < kMaxDecimalBytes);
+  final_value = SafeLeftShift(final_value, bits_offset * CHAR_BIT);
+  final_value |= value;
+  return Decimal32(final_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;
+
+  uint32_t result = 0;
+  memcpy(reinterpret_cast<uint8_t*>(&result) + kMaxDecimalBytes - length, bytes, length);
+
+  const auto value = bit_util::FromBigEndian(result);
+  const int32_t bits_offset = std::max(0, length - kMaxDecimalBytes);
+  if (bits_offset == 8) {
+    return Decimal64(value);
+  }
+
+  int32_t final_value = -1 * (is_negative && length < kMaxDecimalBytes);
+  final_value = SafeLeftShift(final_value, bits_offset * CHAR_BIT);
+  final_value |= value;
+  return Decimal64(final_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 +1488,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..b099d754af23e 100644
--- a/cpp/src/arrow/util/decimal.h
+++ b/cpp/src/arrow/util/decimal.h
@@ -31,6 +31,250 @@
 
 namespace arrow {
 
+/// 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;
+
+  /// \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 {
+    constexpr auto min_value = std::numeric_limits<T>::min();
+    constexpr auto max_value = std::numeric_limits<T>::max();
+    const auto& self = *this;
+    if (self < min_value || self > max_value) {
+      return Status::Invalid("Invalid cast from Decimal32 value to ", sizeof(T),
+                             "byte integer");
+    }
+    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) {}
+
+  /// \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 {
+    constexpr auto min_value = std::numeric_limits<T>::min();
+    constexpr auto max_value = std::numeric_limits<T>::max();
+    const auto& self = *this;
+    if (self < min_value || self > max_value) {
+      return Status::Invalid("Invalid cast from Decimal64 value to ", sizeof(T),
+                             "byte integer");
+    }
+    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 89f755af88316..3bc746c32c80c 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..71fc354f465eb 100644
--- a/cpp/src/arrow/util/decimal_test.cc
+++ b/cpp/src/arrow/util/decimal_test.cc
@@ -623,9 +623,9 @@ class DecimalFromIntegerTest : public ::testing::Test {
     ASSERT_OK_AND_ASSIGN(const 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;
   }
 };
 
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/parquet/arrow/arrow_reader_writer_test.cc b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
index 64030e0f90d54..705f32e51f7b8 100644
--- a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
+++ b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
@@ -204,10 +204,10 @@ ParquetType::type get_physical_type(const DataType& type) {
     case ArrowId::UINT16:
     case ArrowId::INT16:
     case ArrowId::UINT32:
-    case ArrowId::INT32:
+    case ArrowId::INT32:    
       return ParquetType::INT32;
     case ArrowId::UINT64:
-    case ArrowId::INT64:
+    case ArrowId::INT64:    
       return ParquetType::INT64;
     case ArrowId::FLOAT:
       return ParquetType::FLOAT;
@@ -219,7 +219,7 @@ ParquetType::type get_physical_type(const DataType& type) {
     case ArrowId::STRING:
     case ArrowId::LARGE_STRING:
       return ParquetType::BYTE_ARRAY;
-    case ArrowId::FIXED_SIZE_BINARY:
+    case ArrowId::FIXED_SIZE_BINARY:    
     case ArrowId::DECIMAL128:
     case ArrowId::DECIMAL256:
     case ArrowId::HALF_FLOAT:
@@ -850,10 +850,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;
 
@@ -4093,11 +4093,11 @@ 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;
@@ -5041,9 +5041,9 @@ class TestIntegerAnnotateDecimalTypeParquetIO : public TestParquetIO<TestType> {
   }
 };
 
-typedef ::testing::Types<
-    DecimalWithPrecisionAndScale<1>, DecimalWithPrecisionAndScale<5>,
-    DecimalWithPrecisionAndScale<10>, DecimalWithPrecisionAndScale<18>,
+typedef ::testing::Types<    
+    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 9f60cd31d3541..e44207a069f10 100644
--- a/cpp/src/parquet/arrow/arrow_schema_test.cc
+++ b/cpp/src/parquet/arrow/arrow_schema_test.cc
@@ -180,12 +180,12 @@ TEST_F(TestConvertParquetSchema, ParquetAnnotatedFields) {
   std::vector<FieldConstructionArguments> cases = {
       {"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)},
-      {"decimal(16, 4)", LogicalType::Decimal(16, 4), ParquetType::INT64, -1,
-       ::arrow::decimal(16, 4)},
-      {"decimal(32, 8)", LogicalType::Decimal(32, 8), ParquetType::FIXED_LEN_BYTE_ARRAY,
-       16, ::arrow::decimal(32, 8)},
+      {"decimal128(8, 2)", LogicalType::Decimal(8, 2), ParquetType::INT32, -1,
+       ::arrow::decimal128(8, 2)},
+      {"decimal128(16, 4)", LogicalType::Decimal(16, 4), ParquetType::INT64, -1,
+       ::arrow::decimal128(16, 4)},
+      {"decimal128(32, 8)", LogicalType::Decimal(32, 8), ParquetType::FIXED_LEN_BYTE_ARRAY,
+       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)},
@@ -845,13 +845,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),
+      {"decimal128(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),
+      {"decimal128(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),
+      {"decimal128(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),
+      {"decimal128(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},
@@ -1378,7 +1378,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..3b12ec23f6a96 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::decimal32(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/format/Schema.fbs b/format/Schema.fbs
index a03ca31ae97c4..8abe6ff29c94c 100644
--- a/format/Schema.fbs
+++ b/format/Schema.fbs
@@ -24,6 +24,7 @@
 /// Version 1.3 - Add Run-End Encoded.
 /// Version 1.4 - Add BinaryView, Utf8View, variadicBufferCounts, ListView, and
 /// LargeListView.
+/// Version 1.5 - Add Decimal32 and Decimal64
 
 namespace org.apache.arrow.flatbuf;
 
@@ -222,9 +223,9 @@ table RunEndEncoded {
 }
 
 /// Exact decimal value represented as an integer value in two's
-/// complement. Currently only 128-bit (16-byte) and 256-bit (32-byte) integers
-/// are used. The representation uses the endianness indicated
-/// in the Schema.
+/// complement. Currently 32-bit (4-byte), 64-bit (8-byte), 
+/// 128-bit (16-byte) and 256-bit (32-byte) integers are used.
+/// The representation uses the endianness indicated in the Schema.
 table Decimal {
   /// Total number of decimal digits
   precision: int;
@@ -232,7 +233,7 @@ table Decimal {
   /// Number of digits after the decimal point "."
   scale: int;
 
-  /// Number of bits per value. The only accepted widths are 128 and 256.
+  /// Number of bits per value. The accepted widths are 32, 64, 128 and 256.
   /// We use bitWidth for consistency with Int::bitWidth.
   bitWidth: int = 128;
 }