diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index 95114d8d8a5..a5cb61d6b55 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -220,6 +220,14 @@ Result<Datum> ReplaceWithMask(const Datum& values, const Datum& mask,
   return CallFunction("replace_with_mask", {values, mask, replacements}, ctx);
 }
 
+Result<Datum> FillNullForward(const Datum& values, ExecContext* ctx) {
+  return CallFunction("fill_null_forward", {values}, ctx);
+}
+
+Result<Datum> FillNullBackward(const Datum& values, ExecContext* ctx) {
+  return CallFunction("fill_null_backward", {values}, ctx);
+}
+
 Result<std::shared_ptr<Array>> SortIndices(const Array& values,
                                            const ArraySortOptions& options,
                                            ExecContext* ctx) {
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 8788d5d160e..152005093dc 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -246,6 +246,34 @@ ARROW_EXPORT
 Result<Datum> ReplaceWithMask(const Datum& values, const Datum& mask,
                               const Datum& replacements, ExecContext* ctx = NULLPTR);
 
+/// \brief FillNullForward fill null values in forward direction
+///
+/// The output array will be of the same type as the input values
+/// array, with replaced null values in forward direction.
+///
+/// For example given values = ["a", "b", "c", null, null, "f"],
+/// the output will be = ["a", "b", "c", "c", "c", "f"]
+///
+/// \param[in] values datum from which to take
+/// \param[in] ctx the function execution context, optional
+/// \return the resulting datum
+ARROW_EXPORT
+Result<Datum> FillNullForward(const Datum& values, ExecContext* ctx = NULLPTR);
+
+/// \brief FillNullBackward fill null values in backward direction
+///
+/// The output array will be of the same type as the input values
+/// array, with replaced null values in backward direction.
+///
+/// For example given values = ["a", "b", "c", null, null, "f"],
+/// the output will be = ["a", "b", "c", "f", "f", "f"]
+///
+/// \param[in] values datum from which to take
+/// \param[in] ctx the function execution context, optional
+/// \return the resulting datum
+ARROW_EXPORT
+Result<Datum> FillNullBackward(const Datum& values, ExecContext* ctx = NULLPTR);
+
 /// \brief Take from an array of values at indices in another array
 ///
 /// The output array will be of the same type as the input values
diff --git a/cpp/src/arrow/compute/kernels/vector_replace.cc b/cpp/src/arrow/compute/kernels/vector_replace.cc
index 63d0ed94b56..35790e96af4 100644
--- a/cpp/src/arrow/compute/kernels/vector_replace.cc
+++ b/cpp/src/arrow/compute/kernels/vector_replace.cc
@@ -442,23 +442,404 @@ struct ReplaceWithMaskFunctor {
     }
     return ReplaceWithMask<Type>::ExecArrayMask(ctx, array, mask, replacements, output);
   }
+
+  static std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
+    return KernelSignature::Make(
+        {InputType::Array(get_id.id), InputType(boolean()), InputType(get_id.id)},
+        OutputType(FirstType));
+  }
 };
 
-}  // namespace
+// This is for fixed-size types only
+template <typename Type>
+void FillNullInDirectionImpl(const ArrayData& current_chunk, const uint8_t* null_bitmap,
+                             ArrayData* output, int8_t direction,
+                             const ArrayData& last_valid_value_chunk,
+                             int64_t* last_valid_value_offset) {
+  uint8_t* out_bitmap = output->buffers[0]->mutable_data();
+  uint8_t* out_values = output->buffers[1]->mutable_data();
+  arrow::internal::CopyBitmap(current_chunk.buffers[0]->data(), current_chunk.offset,
+                              current_chunk.length, out_bitmap, output->offset);
+  ReplaceWithMask<Type>::CopyData(*current_chunk.type, out_values,
+                                  /*out_offset=*/output->offset, current_chunk,
+                                  /*in_offset=*/0, current_chunk.length);
+
+  bool has_fill_value = *last_valid_value_offset != -1;
+  int64_t write_offset = direction == 1 ? 0 : current_chunk.length - 1;
+  int64_t bitmap_offset = 0;
+
+  arrow::internal::OptionalBitBlockCounter counter(null_bitmap, output->offset,
+                                                   current_chunk.length);
+  bool use_current_chunk = false;
+  while (bitmap_offset < current_chunk.length) {
+    BitBlockCount block = counter.NextBlock();
+    if (block.AllSet()) {
+      *last_valid_value_offset =
+          write_offset + direction * (block.length - 1 + bitmap_offset);
+      has_fill_value = true;
+      use_current_chunk = true;
+    } else {
+      uint64_t block_start_offset = write_offset + direction * bitmap_offset;
+      uint64_t write_value_offset = block_start_offset;
+      if (block.popcount) {
+        for (int64_t i = 0; i < block.length; i++, write_value_offset += direction) {
+          auto current_bit = bit_util::GetBit(null_bitmap, bitmap_offset + i);
+          if (!current_bit) {
+            if (has_fill_value) {
+              ReplaceWithMask<Type>::CopyData(
+                  *current_chunk.type, out_values, write_value_offset,
+                  use_current_chunk ? current_chunk : last_valid_value_chunk,
+                  *last_valid_value_offset,
+                  /*length=*/1);
+              bit_util::SetBitTo(out_bitmap, write_value_offset, true);
+            }
+          } else {
+            has_fill_value = true;
+            use_current_chunk = true;
+            *last_valid_value_offset = write_value_offset;
+          }
+        }
+      } else {
+        for (int64_t i = 0; i < block.length; i++, write_value_offset += direction) {
+          if (has_fill_value) {
+            ReplaceWithMask<Type>::CopyData(
+                *current_chunk.type, out_values, write_value_offset,
+                use_current_chunk ? current_chunk : last_valid_value_chunk,
+                *last_valid_value_offset,
+                /*length=*/1);
+            bit_util::SetBitTo(out_bitmap, write_value_offset, true);
+          }
+        }
+      }
+    }
+    bitmap_offset += block.length;
+  }
+  output->null_count = -1;
+  output->GetNullCount();
+}
 
-const FunctionDoc replace_with_mask_doc(
-    "Replace items selected with a mask",
-    ("Given an array and a boolean mask (either scalar or of equal length),\n"
-     "along with replacement values (either scalar or array),\n"
-     "each element of the array for which the corresponding mask element is\n"
-     "true will be replaced by the next value from the replacements,\n"
-     "or with null if the mask is null.\n"
-     "Hence, for replacement arrays, len(replacements) == sum(mask == true)."),
-    {"values", "mask", "replacements"});
+template <typename Type, typename Enable = void>
+struct FillNullExecutor {};
 
-void RegisterVectorReplace(FunctionRegistry* registry) {
-  auto func = std::make_shared<VectorFunction>("replace_with_mask", Arity::Ternary(),
-                                               &replace_with_mask_doc);
+template <typename Type>
+struct FillNullExecutor<Type, enable_if_boolean<Type>> {
+  static Status ExecFillNull(KernelContext* ctx, const ArrayData& array,
+                             const uint8_t* reversed_bitmap, ArrayData* output,
+                             int8_t direction, const ArrayData& last_valid_value_chunk,
+                             int64_t* last_valid_value_offset) {
+    FillNullInDirectionImpl<Type>(array, reversed_bitmap, output, direction,
+                                  last_valid_value_chunk, last_valid_value_offset);
+    return Status::OK();
+  }
+};
+
+template <typename Type>
+struct FillNullExecutor<
+    Type, enable_if_t<is_number_type<Type>::value ||
+                      std::is_same<Type, MonthDayNanoIntervalType>::value>> {
+  static Status ExecFillNull(KernelContext* ctx, const ArrayData& array,
+                             const uint8_t* reversed_bitmap, ArrayData* output,
+                             int8_t direction, const ArrayData& last_valid_value_chunk,
+                             int64_t* last_valid_value_offset) {
+    FillNullInDirectionImpl<Type>(array, reversed_bitmap, output, direction,
+                                  last_valid_value_chunk, last_valid_value_offset);
+    return Status::OK();
+  }
+};
+
+template <typename Type>
+struct FillNullExecutor<Type, enable_if_fixed_size_binary<Type>> {
+  static Status ExecFillNull(KernelContext* ctx, const ArrayData& array,
+                             const uint8_t* reversed_bitmap, ArrayData* output,
+                             int8_t direction, const ArrayData& last_valid_value_chunk,
+                             int64_t* last_valid_value_offset) {
+    FillNullInDirectionImpl<Type>(array, reversed_bitmap, output, direction,
+                                  last_valid_value_chunk, last_valid_value_offset);
+    return Status::OK();
+  }
+};
+
+template <typename Type>
+struct FillNullExecutor<Type, enable_if_base_binary<Type>> {
+  using offset_type = typename Type::offset_type;
+  using BuilderType = typename TypeTraits<Type>::BuilderType;
+
+  static Status ExecFillNull(KernelContext* ctx, const ArrayData& current_chunk,
+                             const uint8_t* reversed_bitmap, ArrayData* output,
+                             int8_t direction, const ArrayData& last_valid_value_chunk,
+                             int64_t* last_valid_value_offset) {
+    BuilderType builder(current_chunk.type, ctx->memory_pool());
+    RETURN_NOT_OK(builder.Reserve(current_chunk.length));
+    RETURN_NOT_OK(builder.ReserveData(current_chunk.buffers[2]->size()));
+    int64_t array_value_index = direction == 1 ? 0 : current_chunk.length - 1;
+    const uint8_t* data = current_chunk.buffers[2]->data();
+    const uint8_t* data_prev = last_valid_value_chunk.buffers[2]->data();
+    const offset_type* offsets = current_chunk.GetValues<offset_type>(1);
+    const offset_type* offsets_prev = last_valid_value_chunk.GetValues<offset_type>(1);
+
+    bool has_fill_value_last_chunk = *last_valid_value_offset != -1;
+    bool has_fill_value_current_chunk = false;
+    /*tuple for store: <use current_chunk(true) or last_valid_chunk(false),
+     * start offset of the current value, end offset for the current value>*/
+    std::vector<std::tuple<bool, offset_type, offset_type>> offsets_reversed;
+    RETURN_NOT_OK(VisitNullBitmapInline<>(
+        reversed_bitmap, output->offset, current_chunk.length,
+        current_chunk.GetNullCount(),
+        [&]() {
+          const offset_type offset0 = offsets[array_value_index];
+          const offset_type offset1 = offsets[array_value_index + 1];
+          offsets_reversed.push_back(
+              std::make_tuple(/*current_chunk=*/true, offset0, offset1 - offset0));
+          *last_valid_value_offset = array_value_index;
+          has_fill_value_current_chunk = true;
+          has_fill_value_last_chunk = false;
+          array_value_index += direction;
+          return Status::OK();
+        },
+        [&]() {
+          if (has_fill_value_current_chunk) {
+            const offset_type offset0 = offsets[*last_valid_value_offset];
+            const offset_type offset1 = offsets[*last_valid_value_offset + 1];
+            offsets_reversed.push_back(
+                std::make_tuple(/*current_chunk=*/true, offset0, offset1 - offset0));
+          } else if (has_fill_value_last_chunk) {
+            const offset_type offset0 = offsets_prev[*last_valid_value_offset];
+            const offset_type offset1 = offsets_prev[*last_valid_value_offset + 1];
+            offsets_reversed.push_back(
+                std::make_tuple(/*current_chunk=*/false, offset0, offset1 - offset0));
+          } else {
+            offsets_reversed.push_back(std::make_tuple(/*current_chunk=*/false, -1, -1));
+          }
+          array_value_index += direction;
+          return Status::OK();
+        }));
+
+    if (direction == 1) {
+      for (auto it = offsets_reversed.begin(); it != offsets_reversed.end(); ++it) {
+        if (std::get<1>(*it) == -1 && std::get<2>(*it) == -1) {
+          RETURN_NOT_OK(builder.AppendNull());
+        } else if (std::get<0>(*it)) {
+          RETURN_NOT_OK(builder.Append(data + std::get<1>(*it), std::get<2>(*it)));
+        } else {
+          RETURN_NOT_OK(builder.Append(data_prev + std::get<1>(*it), std::get<2>(*it)));
+        }
+      }
+    } else {
+      for (auto it = offsets_reversed.rbegin(); it != offsets_reversed.rend(); ++it) {
+        if (std::get<1>(*it) == -1 && std::get<2>(*it) == -1) {
+          RETURN_NOT_OK(builder.AppendNull());
+        } else if (std::get<0>(*it)) {
+          RETURN_NOT_OK(builder.Append(data + std::get<1>(*it), std::get<2>(*it)));
+        } else {
+          RETURN_NOT_OK(builder.Append(data_prev + std::get<1>(*it), std::get<2>(*it)));
+        }
+      }
+    }
+
+    std::shared_ptr<Array> temp_output;
+    RETURN_NOT_OK(builder.Finish(&temp_output));
+    *output = *temp_output->data();
+    // Builder type != logical type due to GenerateTypeAgnosticVarBinaryBase
+    output->type = current_chunk.type;
+    return Status::OK();
+  }
+};
+
+template <typename Type>
+struct FillNullExecutor<Type, enable_if_null<Type>> {
+  static Status ExecFillNull(KernelContext* ctx, const ArrayData& array,
+                             const uint8_t* reversed_bitmap, ArrayData* output,
+                             int8_t direction, const ArrayData& last_valid_value_chunk,
+                             int64_t* last_valid_value_offset) {
+    *output = array;
+    return Status::OK();
+  }
+};
+
+template <typename Type>
+struct FillNullForwardFunctor {
+  static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+    switch (batch[0].kind()) {
+      case Datum::ARRAY: {
+        auto array_input = *batch[0].array();
+        int64_t last_valid_value_offset = -1;
+        return FillNullForwardArray(ctx, array_input, out, array_input,
+                                    &last_valid_value_offset);
+      }
+      case Datum::CHUNKED_ARRAY: {
+        return FillNullForwardChunkedArray(ctx, batch[0].chunked_array(), out);
+      }
+      default:
+        break;
+    }
+    return Status::NotImplemented("Unsupported type for fill_null_forward: ",
+                                  batch[0].ToString());
+  }
+
+  static Status FillNullForwardArray(KernelContext* ctx, const ArrayData& array,
+                                     Datum* out, const ArrayData& last_valid_value_chunk,
+                                     int64_t* last_valid_value_offset) {
+    ArrayData* output = out->array().get();
+    output->length = array.length;
+    int8_t direction = 1;
+
+    if (array.MayHaveNulls()) {
+      ARROW_ASSIGN_OR_RAISE(
+          auto null_bitmap,
+          arrow::internal::CopyBitmap(ctx->memory_pool(), array.buffers[0]->data(),
+                                      array.offset, array.length));
+      return FillNullExecutor<Type>::ExecFillNull(ctx, array, null_bitmap->data(), output,
+                                                  direction, last_valid_value_chunk,
+                                                  last_valid_value_offset);
+    } else {
+      if (array.length > 0) {
+        *last_valid_value_offset = array.length - 1;
+      }
+      *output = array;
+    }
+    return Status::OK();
+  }
+
+  static Status FillNullForwardChunkedArray(KernelContext* ctx,
+                                            const std::shared_ptr<ChunkedArray>& values,
+                                            Datum* out) {
+    if (values->null_count() == 0) {
+      *out = Datum(values);
+      return Status::OK();
+    }
+    if (values->null_count() == values->length()) {
+      *out = Datum(values);
+      return Status::OK();
+    }
+
+    ArrayVector new_chunks;
+    if (values->length() > 0) {
+      ArrayData* array_with_current = values->chunk(/*first_chunk=*/0)->data().get();
+      int64_t last_valid_value_offset = -1;
+
+      for (const auto& chunk : values->chunks()) {
+        if (is_fixed_width(out->type()->id())) {
+          auto* output = out->mutable_array();
+          auto bit_width = checked_cast<const FixedWidthType&>(*output->type).bit_width();
+          auto data_bytes = bit_util::BytesForBits(bit_width * chunk->length());
+          ARROW_ASSIGN_OR_RAISE(output->buffers[0], ctx->AllocateBitmap(chunk->length()));
+          ARROW_ASSIGN_OR_RAISE(output->buffers[1], ctx->Allocate(data_bytes));
+        }
+        RETURN_NOT_OK(FillNullForwardArray(ctx, *chunk->data(), out, *array_with_current,
+                                           &last_valid_value_offset));
+        if (chunk->null_count() != chunk->length()) {
+          array_with_current = &*chunk->data();
+        }
+        new_chunks.push_back(MakeArray(out->make_array()->data()->Copy()));
+      }
+    }
+
+    auto output = std::make_shared<ChunkedArray>(std::move(new_chunks), values->type());
+    *out = Datum(output);
+    return Status::OK();
+  }
+
+  static std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
+    return KernelSignature::Make({InputType::Array(get_id.id)}, OutputType(FirstType));
+  }
+};
+
+template <typename Type>
+struct FillNullBackwardFunctor {
+  static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+    switch (batch[0].kind()) {
+      case Datum::ARRAY: {
+        auto array_input = *batch[0].array();
+        int64_t last_valid_value_offset = -1;
+        return FillNullBackwardArray(ctx, array_input, out, array_input,
+                                     &last_valid_value_offset);
+      }
+      case Datum::CHUNKED_ARRAY: {
+        return FillNullBackwardChunkedArray(ctx, batch[0].chunked_array(), out);
+      }
+      default:
+        break;
+    }
+    return Status::NotImplemented("Unsupported type for fill_null_backward operation: ",
+                                  batch[0].ToString());
+  }
+
+  static Status FillNullBackwardArray(KernelContext* ctx, const ArrayData& array,
+                                      Datum* out, const ArrayData& last_valid_value_chunk,
+                                      int64_t* last_valid_value_offset) {
+    ArrayData* output = out->array().get();
+    output->length = array.length;
+    int8_t direction = -1;
+
+    if (array.MayHaveNulls()) {
+      ARROW_ASSIGN_OR_RAISE(
+          auto reversed_bitmap,
+          arrow::internal::ReverseBitmap(ctx->memory_pool(), array.buffers[0]->data(),
+                                         array.offset, array.length));
+      return FillNullExecutor<Type>::ExecFillNull(
+          ctx, array, reversed_bitmap->data(), output, direction, last_valid_value_chunk,
+          last_valid_value_offset);
+    } else {
+      if (array.length > 0) {
+        *last_valid_value_offset = 0;
+      }
+      *output = array;
+    }
+    return Status::OK();
+  }
+
+  static Status FillNullBackwardChunkedArray(KernelContext* ctx,
+                                             const std::shared_ptr<ChunkedArray>& values,
+                                             Datum* out) {
+    if (values->null_count() == 0) {
+      *out = Datum(values);
+      return Status::OK();
+    }
+    if (values->null_count() == values->length()) {
+      *out = Datum(values);
+      return Status::OK();
+    }
+    std::vector<std::shared_ptr<Array>> new_chunks;
+
+    if (values->length() > 0) {
+      auto chunks_length = static_cast<int>(values->chunks().size());
+      ArrayData* array_with_current =
+          values->chunk(/*first_chunk=*/chunks_length - 1)->data().get();
+      int64_t last_valid_value_offset = -1;
+      auto chunks = values->chunks();
+      for (int i = chunks_length - 1; i >= 0; --i) {
+        const auto& chunk = chunks[i];
+        if (is_fixed_width(out->type()->id())) {
+          auto* output = out->mutable_array();
+          auto bit_width = checked_cast<const FixedWidthType&>(*output->type).bit_width();
+          auto data_bytes = bit_util::BytesForBits(bit_width * chunk->length());
+          ARROW_ASSIGN_OR_RAISE(output->buffers[0], ctx->AllocateBitmap(chunk->length()));
+          ARROW_ASSIGN_OR_RAISE(output->buffers[1], ctx->Allocate(data_bytes));
+        }
+        RETURN_NOT_OK(FillNullBackwardArray(ctx, *chunk->data(), out, *array_with_current,
+                                            &last_valid_value_offset));
+        if (chunk->null_count() != chunk->length()) {
+          array_with_current = &*chunk->data();
+        }
+        new_chunks.push_back(MakeArray(out->make_array()->data()->Copy()));
+      }
+    }
+
+    std::reverse(new_chunks.begin(), new_chunks.end());
+    auto output = std::make_shared<ChunkedArray>(std::move(new_chunks), values->type());
+    *out = Datum(output);
+    return Status::OK();
+  }
+
+  static std::shared_ptr<KernelSignature> GetSignature(detail::GetTypeId get_id) {
+    return KernelSignature::Make({InputType::Array(get_id.id)}, OutputType(FirstType));
+  }
+};
+}  // namespace
+
+template <template <class> class Functor>
+void RegisterVectorFunction(FunctionRegistry* registry,
+                            std::shared_ptr<VectorFunction> func) {
   auto add_kernel = [&](detail::GetTypeId get_id, ArrayKernelExec exec) {
     VectorKernel kernel;
     kernel.can_execute_chunkwise = false;
@@ -469,14 +850,14 @@ void RegisterVectorReplace(FunctionRegistry* registry) {
       kernel.null_handling = NullHandling::type::COMPUTED_NO_PREALLOCATE;
     }
     kernel.mem_allocation = MemAllocation::type::PREALLOCATE;
-    kernel.signature = KernelSignature::Make(
-        {InputType::Array(get_id.id), InputType(boolean()), InputType(get_id.id)},
-        OutputType(FirstType));
+    kernel.signature = Functor<FixedSizeBinaryType>::GetSignature(get_id.id);
     kernel.exec = std::move(exec);
+    kernel.can_execute_chunkwise = false;
+    kernel.output_chunked = false;
     DCHECK_OK(func->AddKernel(std::move(kernel)));
   };
   auto add_primitive_kernel = [&](detail::GetTypeId get_id) {
-    add_kernel(get_id, GenerateTypeAgnosticPrimitive<ReplaceWithMaskFunctor>(get_id));
+    add_kernel(get_id, GenerateTypeAgnosticPrimitive<Functor>(get_id));
   };
   for (const auto& ty : NumericTypes()) {
     add_primitive_kernel(ty);
@@ -489,17 +870,57 @@ void RegisterVectorReplace(FunctionRegistry* registry) {
   }
   add_primitive_kernel(null());
   add_primitive_kernel(boolean());
-  add_kernel(Type::FIXED_SIZE_BINARY, ReplaceWithMaskFunctor<FixedSizeBinaryType>::Exec);
-  add_kernel(Type::DECIMAL128, ReplaceWithMaskFunctor<FixedSizeBinaryType>::Exec);
-  add_kernel(Type::DECIMAL256, ReplaceWithMaskFunctor<FixedSizeBinaryType>::Exec);
+  add_kernel(Type::FIXED_SIZE_BINARY, Functor<FixedSizeBinaryType>::Exec);
+  add_kernel(Type::DECIMAL128, Functor<FixedSizeBinaryType>::Exec);
+  add_kernel(Type::DECIMAL256, Functor<FixedSizeBinaryType>::Exec);
   for (const auto& ty : BaseBinaryTypes()) {
-    add_kernel(ty->id(), GenerateTypeAgnosticVarBinaryBase<ReplaceWithMaskFunctor>(*ty));
+    add_kernel(ty->id(), GenerateTypeAgnosticVarBinaryBase<Functor>(*ty));
   }
   // TODO: list types
   DCHECK_OK(registry->AddFunction(std::move(func)));
 
   // TODO(ARROW-9431): "replace_with_indices"
 }
+
+const FunctionDoc replace_with_mask_doc(
+    "Replace items selected with a mask",
+    ("Given an array and a boolean mask (either scalar or of equal length),\n"
+     "along with replacement values (either scalar or array),\n"
+     "each element of the array for which the corresponding mask element is\n"
+     "true will be replaced by the next value from the replacements,\n"
+     "or with null if the mask is null.\n"
+     "Hence, for replacement arrays, len(replacements) == sum(mask == true)."),
+    {"values", "mask", "replacements"});
+
+const FunctionDoc fill_null_forward_doc(
+    "Carry non-null values forward to fill null slots",
+    ("Given an array, propagate last valid observation forward to next valid\n"
+     "or nothing if all previous values are null."),
+    {"values"});
+
+const FunctionDoc fill_null_backward_doc(
+    "Carry non-null values backward to fill null slots",
+    ("Given an array, propagate next valid observation backward to previous valid\n"
+     "or nothing if all next values are null."),
+    {"values"});
+
+void RegisterVectorReplace(FunctionRegistry* registry) {
+  {
+    auto func = std::make_shared<VectorFunction>("replace_with_mask", Arity::Ternary(),
+                                                 &replace_with_mask_doc);
+    RegisterVectorFunction<ReplaceWithMaskFunctor>(registry, func);
+  }
+  {
+    auto func = std::make_shared<VectorFunction>("fill_null_forward", Arity::Unary(),
+                                                 &fill_null_forward_doc);
+    RegisterVectorFunction<FillNullForwardFunctor>(registry, func);
+  }
+  {
+    auto func = std::make_shared<VectorFunction>("fill_null_backward", Arity::Unary(),
+                                                 &fill_null_backward_doc);
+    RegisterVectorFunction<FillNullBackwardFunctor>(registry, func);
+  }
+}
 }  // namespace internal
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/vector_replace_test.cc b/cpp/src/arrow/compute/kernels/vector_replace_test.cc
index 421f493c9ad..8d3f0ae85b4 100644
--- a/cpp/src/arrow/compute/kernels/vector_replace_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_replace_test.cc
@@ -18,8 +18,10 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include "arrow/array/concatenate.h"
 #include "arrow/compute/api_vector.h"
 #include "arrow/compute/kernels/test_util.h"
+#include "arrow/testing/generator.h"
 #include "arrow/testing/gtest_util.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/key_value_metadata.h"
@@ -38,6 +40,8 @@ class TestReplaceKernel : public ::testing::Test {
   using ReplaceFunction = std::function<Result<Datum>(const Datum&, const Datum&,
                                                       const Datum&, ExecContext*)>;
 
+  using FillNullFunction = std::function<Result<Datum>(const Datum&, ExecContext*)>;
+
   Datum mask_scalar(bool value) { return Datum(std::make_shared<BooleanScalar>(value)); }
 
   Datum null_mask_scalar() {
@@ -52,6 +56,10 @@ class TestReplaceKernel : public ::testing::Test {
     return ArrayFromJSON(type(), value);
   }
 
+  std::shared_ptr<ChunkedArray> chunked_array(const std::vector<std::string>& value) {
+    return ChunkedArrayFromJSON(type(), value);
+  }
+
   std::shared_ptr<Array> mask(const std::string& value) {
     return ArrayFromJSON(boolean(), value);
   }
@@ -80,6 +88,56 @@ class TestReplaceKernel : public ::testing::Test {
     AssertArraysApproxEqual(*expected, *actual.make_array(), /*verbose=*/true);
   }
 
+  void AssertFillNullArray(FillNullFunction func, const std::shared_ptr<Array>& array,
+                           const std::shared_ptr<Array>& expected) {
+    SCOPED_TRACE("Array: " + array->ToString());
+
+    ASSERT_OK_AND_ASSIGN(auto actual, func(array, nullptr));
+    SCOPED_TRACE("Actual: " + actual.make_array()->ToString());
+
+    ASSERT_TRUE(actual.is_array());
+    ASSERT_OK(actual.make_array()->ValidateFull());
+
+    AssertArraysApproxEqual(*expected, *actual.make_array(), /*verbose=*/true);
+  }
+
+  void AssertFillNullArraySlices(FillNullFunction func,
+                                 const std::shared_ptr<Array>& first_input_array,
+                                 const std::shared_ptr<Array>& array_expected_2,
+                                 const std::shared_ptr<Array>& array_expected_3,
+                                 const std::shared_ptr<Array>& array_expected_4) {
+    uint8_t slice_length = 2;
+    for (int64_t slice = 0; slice < first_input_array->length() / slice_length; slice++) {
+      auto sliced_array = first_input_array->Slice(slice * slice_length, slice_length);
+      auto sliced_array_expected =
+          array_expected_2->Slice(slice * slice_length, slice_length);
+      this->AssertFillNullArray(func, sliced_array, sliced_array_expected);
+    }
+
+    slice_length = 3;
+    for (int64_t slice = 0; slice < first_input_array->length() / slice_length; slice++) {
+      auto sliced_array = first_input_array->Slice(slice * slice_length, slice_length);
+      auto sliced_array_expected =
+          array_expected_3->Slice(slice * slice_length, slice_length);
+      this->AssertFillNullArray(func, sliced_array, sliced_array_expected);
+    }
+
+    slice_length = 4;
+    for (int64_t slice = 0; slice < first_input_array->length() / slice_length; slice++) {
+      auto sliced_array = first_input_array->Slice(slice * slice_length, slice_length);
+      auto sliced_array_expected =
+          array_expected_4->Slice(slice * slice_length, slice_length);
+      this->AssertFillNullArray(func, sliced_array, sliced_array_expected);
+    }
+  }
+
+  void AssertFillNullChunkedArray(FillNullFunction func,
+                                  const std::shared_ptr<ChunkedArray> array,
+                                  const std::shared_ptr<ChunkedArray>& expected) {
+    ASSERT_OK_AND_ASSIGN(auto actual, func(Datum(*array), nullptr));
+    AssertChunkedEquivalent(*expected, *actual.chunked_array());
+  }
+
   std::shared_ptr<Array> NaiveImpl(
       const typename TypeTraits<T>::ArrayType& array, const BooleanArray& mask,
       const typename TypeTraits<T>::ArrayType& replacements) {
@@ -792,5 +850,685 @@ TYPED_TEST(TestReplaceBinary, ReplaceWithMaskRandom) {
   }
 }
 
+template <typename T>
+class TestFillNullNumeric : public TestReplaceKernel<T> {
+ protected:
+  std::shared_ptr<DataType> type() override { return default_type_instance<T>(); }
+};
+template <typename T>
+class TestFillNullDecimal : public TestReplaceKernel<T> {
+ protected:
+  std::shared_ptr<DataType> type() override { return default_type_instance<T>(); }
+};
+template <typename T>
+class TestFillNullBinary : public TestReplaceKernel<T> {
+ protected:
+  std::shared_ptr<DataType> type() override { return default_type_instance<T>(); }
+};
+
+class TestFillNullType : public TestReplaceKernel<NullType> {
+  std::shared_ptr<DataType> type() override { return default_type_instance<NullType>(); }
+};
+
+TYPED_TEST_SUITE(TestFillNullNumeric, NumericBasedTypes);
+TYPED_TEST_SUITE(TestFillNullDecimal, DecimalArrowTypes);
+TYPED_TEST_SUITE(TestFillNullBinary, BaseBinaryArrowTypes);
+
+TYPED_TEST(TestFillNullNumeric, FillNullValuesForward) {
+  this->AssertFillNullArray(FillNullForward, this->array("[]"), this->array("[]"));
+
+  this->AssertFillNullArray(FillNullForward, this->array("[null, null, null, null]"),
+                            this->array("[null, null, null, null]"));
+  this->AssertFillNullArray(FillNullForward, this->array("[null, null, null, 4]"),
+                            this->array("[null, null, null, 4]"));
+  this->AssertFillNullArray(FillNullForward, this->array("[null, 4, null]"),
+                            this->array("[null, 4, 4]"));
+  this->AssertFillNullArray(FillNullForward, this->array("[null, null, 4, null]"),
+                            this->array("[null, null, 4, 4]"));
+  this->AssertFillNullArray(FillNullForward, this->array("[null, null, null, 4, null]"),
+                            this->array("[null, null, null, 4, 4]"));
+  this->AssertFillNullArray(FillNullForward, this->array("[null, null, 4,null, 5, null]"),
+                            this->array("[null, null, 4, 4, 5, 5]"));
+
+  this->AssertFillNullArray(FillNullForward, this->array("[1,4,null]"),
+                            this->array("[1,4,4]"));
+  this->AssertFillNullArray(FillNullForward,
+                            this->array("[1, 4, null, null, null, null]"),
+                            this->array("[1, 4 ,4, 4, 4, 4]"));
+  this->AssertFillNullArray(FillNullForward, this->array("[1, 4, null, 5, null, null]"),
+                            this->array("[1, 4 ,4, 5, 5, 5]"));
+  this->AssertFillNullArray(FillNullForward,
+                            this->array("[1, 4, null, 5, null, null, 6]"),
+                            this->array("[1, 4 ,4, 5, 5, 5, 6]"));
+  this->AssertFillNullArray(FillNullForward,
+                            this->array("[1, 4, null, 5, null, null, 5]"),
+                            this->array("[1, 4 ,4, 5, 5, 5, 5]"));
+  this->AssertFillNullArray(FillNullForward,
+                            this->array("[1, 4, null, 5, null, 6, null]"),
+                            this->array("[1, 4 ,4, 5, 5, 6, 6]"));
+  this->AssertFillNullArray(FillNullForward, this->array("[1, 4, null, 5, null, 6, 7]"),
+                            this->array("[1, 4 ,4, 5, 5, 6, 7]"));
+  this->AssertFillNullArray(FillNullForward, this->array("[1, 4 ,4, 5, 5, 6, 7]"),
+                            this->array("[1, 4 ,4, 5, 5, 6, 7]"));
+}
+
+TYPED_TEST(TestFillNullDecimal, FillNullValuesForward) {
+  this->AssertFillNullArray(FillNullForward, this->array(R"([])"), this->array(R"([])"));
+
+  this->AssertFillNullArray(FillNullForward, this->array(R"([null, null, null, null])"),
+                            this->array(R"([null, null, null, null])"));
+  this->AssertFillNullArray(FillNullForward,
+                            this->array(R"([null, null, null, "30.00"])"),
+                            this->array(R"([null, null, null, "30.00"])"));
+  this->AssertFillNullArray(FillNullForward, this->array(R"([null, "30.00", null])"),
+                            this->array(R"([null, "30.00", "30.00"])"));
+  this->AssertFillNullArray(FillNullForward,
+                            this->array(R"([null, null, "30.00", null])"),
+                            this->array(R"([null, null, "30.00", "30.00"])"));
+  this->AssertFillNullArray(FillNullForward,
+                            this->array(R"([null, null, null, "30.00", null])"),
+                            this->array(R"([null, null, null, "30.00", "30.00"])"));
+  this->AssertFillNullArray(
+      FillNullForward, this->array(R"([null, null, "30.00",null, "5.00", null])"),
+      this->array(R"([null, null, "30.00", "30.00", "5.00", "5.00"])"));
+
+  this->AssertFillNullArray(FillNullForward, this->array(R"(["10.00","30.00",null])"),
+                            this->array(R"(["10.00","30.00","30.00"])"));
+  this->AssertFillNullArray(
+      FillNullForward, this->array(R"(["10.00", "30.00", null, null, null, null])"),
+      this->array(R"(["10.00", "30.00" ,"30.00", "30.00", "30.00", "30.00"])"));
+  this->AssertFillNullArray(
+      FillNullForward, this->array(R"(["10.00", "30.00", null, "5.00", null, null])"),
+      this->array(R"(["10.00", "30.00" ,"30.00", "5.00", "5.00", "5.00"])"));
+  this->AssertFillNullArray(
+      FillNullForward,
+      this->array(R"(["10.00", "30.00", null, "5.00", null, null, "6.00"])"),
+      this->array(R"(["10.00", "30.00" ,"30.00", "5.00", "5.00", "5.00", "6.00"])"));
+  this->AssertFillNullArray(
+      FillNullForward,
+      this->array(R"(["10.00", "30.00", null, "5.00", null, null, "5.00"])"),
+      this->array(R"(["10.00", "30.00" ,"30.00", "5.00", "5.00", "5.00", "5.00"])"));
+  this->AssertFillNullArray(
+      FillNullForward,
+      this->array(R"(["10.00", "30.00", null, "5.00", null, "6.00", null])"),
+      this->array(R"(["10.00", "30.00" ,"30.00", "5.00", "5.00", "6.00", "6.00"])"));
+  this->AssertFillNullArray(
+      FillNullForward,
+      this->array(R"(["10.00", "30.00", null, "5.00", null, "6.00", "7.00"])"),
+      this->array(R"(["10.00", "30.00" ,"30.00", "5.00", "5.00", "6.00", "7.00"])"));
+  this->AssertFillNullArray(
+      FillNullForward,
+      this->array(R"(["10.00", "30.00" ,"30.00", "5.00", "5.00", "6.00", "7.00"])"),
+      this->array(R"(["10.00", "30.00" ,"30.00", "5.00", "5.00", "6.00", "7.00"])"));
+}
+
+TYPED_TEST(TestFillNullBinary, FillNullValuesForward) {
+  this->AssertFillNullArray(FillNullForward, this->array(R"([])"), this->array(R"([])"));
+
+  this->AssertFillNullArray(FillNullForward, this->array(R"([null, null, null, null])"),
+                            this->array(R"([null, null, null, null])"));
+  this->AssertFillNullArray(FillNullForward, this->array(R"([null, null, null, "ccc"])"),
+                            this->array(R"([null, null, null, "ccc"])"));
+  this->AssertFillNullArray(FillNullForward, this->array(R"([null, "ccc", null])"),
+                            this->array(R"([null, "ccc", "ccc"])"));
+  this->AssertFillNullArray(FillNullForward, this->array(R"([null, null, "ccc", null])"),
+                            this->array(R"([null, null, "ccc", "ccc"])"));
+  this->AssertFillNullArray(FillNullForward,
+                            this->array(R"([null, null, null, "ccc", null])"),
+                            this->array(R"([null, null, null, "ccc", "ccc"])"));
+  this->AssertFillNullArray(FillNullForward,
+                            this->array(R"([null, null, "ccc",null, "xyz", null])"),
+                            this->array(R"([null, null, "ccc", "ccc", "xyz", "xyz"])"));
+
+  this->AssertFillNullArray(FillNullForward, this->array(R"(["aaa","ccc",null])"),
+                            this->array(R"(["aaa","ccc","ccc"])"));
+  this->AssertFillNullArray(FillNullForward,
+                            this->array(R"(["aaa", "ccc", null, null, null, null])"),
+                            this->array(R"(["aaa", "ccc" ,"ccc", "ccc", "ccc", "ccc"])"));
+  this->AssertFillNullArray(FillNullForward,
+                            this->array(R"(["aaa", "ccc", null, "xyz", null, null])"),
+                            this->array(R"(["aaa", "ccc" ,"ccc", "xyz", "xyz", "xyz"])"));
+  this->AssertFillNullArray(
+      FillNullForward, this->array(R"(["aaa", "ccc", null, "xyz", null, null, "qwert"])"),
+      this->array(R"(["aaa", "ccc" ,"ccc", "xyz", "xyz", "xyz", "qwert"])"));
+  this->AssertFillNullArray(
+      FillNullForward, this->array(R"(["aaa", "ccc", null, "xyz", null, null, "xyz"])"),
+      this->array(R"(["aaa", "ccc" ,"ccc", "xyz", "xyz", "xyz", "xyz"])"));
+  this->AssertFillNullArray(
+      FillNullForward, this->array(R"(["aaa", "ccc", null, "xyz", null, "qwert", null])"),
+      this->array(R"(["aaa", "ccc" ,"ccc", "xyz", "xyz", "qwert", "qwert"])"));
+  this->AssertFillNullArray(
+      FillNullForward, this->array(R"(["aaa", "ccc", null, "xyz", null, "qwert", "uy"])"),
+      this->array(R"(["aaa", "ccc" ,"ccc", "xyz", "xyz", "qwert", "uy"])"));
+  this->AssertFillNullArray(
+      FillNullForward,
+      this->array(R"(["aaa", "ccc" ,"ccc", "xyz", "xyz", "qwert", "uy"])"),
+      this->array(R"(["aaa", "ccc" ,"ccc", "xyz", "xyz", "qwert", "uy"])"));
+}
+
+TYPED_TEST(TestFillNullNumeric, FillNullValuesBackward) {
+  this->AssertFillNullArray(FillNullBackward, this->array("[]"), this->array("[]"));
+  this->AssertFillNullArray(FillNullBackward, this->array("[null, null, null, null]"),
+                            this->array("[null, null, null, null]"));
+  this->AssertFillNullArray(FillNullBackward, this->array("[null, 4, null, null, null]"),
+                            this->array("[4, 4,null, null, null]"));
+  this->AssertFillNullArray(FillNullBackward, this->array("[null, null, null, 4]"),
+                            this->array("[4, 4, 4, 4]"));
+  this->AssertFillNullArray(FillNullBackward, this->array("[null, 4, null]"),
+                            this->array("[4, 4, null]"));
+  this->AssertFillNullArray(FillNullBackward, this->array("[null, null, 4, null]"),
+                            this->array("[4, 4, 4, null]"));
+  this->AssertFillNullArray(FillNullBackward, this->array("[null, null, null, 4, null]"),
+                            this->array("[4, 4, 4, 4, null]"));
+  this->AssertFillNullArray(FillNullBackward,
+                            this->array("[null, null, 4,null, 5, null]"),
+                            this->array("[4, 4, 4, 5, 5, null]"));
+
+  this->AssertFillNullArray(FillNullBackward, this->array("[1, 4, null]"),
+                            this->array("[1, 4, null]"));
+  this->AssertFillNullArray(FillNullBackward,
+                            this->array("[1, 4, null, null, null, null]"),
+                            this->array("[1, 4 ,null, null, null, null]"));
+  this->AssertFillNullArray(FillNullBackward, this->array("[1, 4, null, 5, null, null]"),
+                            this->array("[1, 4 , 5, 5, null, null]"));
+  this->AssertFillNullArray(FillNullBackward,
+                            this->array("[1, 4, null, 5, null, null, 6]"),
+                            this->array("[1, 4 ,5, 5, 6, 6, 6]"));
+  this->AssertFillNullArray(FillNullBackward,
+                            this->array("[1, 4, null, 5, null, null, 5]"),
+                            this->array("[1, 4 ,5 , 5, 5, 5, 5]"));
+  this->AssertFillNullArray(FillNullBackward,
+                            this->array("[1, 4, null, 5, null, 6, null]"),
+                            this->array("[1, 4 ,5 , 5, 6, 6, null]"));
+  this->AssertFillNullArray(FillNullBackward, this->array("[1, 4, null, 5, null, 6, 7]"),
+                            this->array("[1, 4 ,5, 5, 6, 6, 7]"));
+  this->AssertFillNullArray(FillNullBackward, this->array("[1, 4 ,5, 5, 6, 6, 7]"),
+                            this->array("[1, 4 ,5, 5, 6, 6, 7]"));
+}
+
+TYPED_TEST(TestFillNullDecimal, FillNullValuesBackward) {
+  this->AssertFillNullArray(FillNullBackward, this->array(R"([])"), this->array(R"([])"));
+
+  this->AssertFillNullArray(FillNullBackward, this->array(R"([null, null, null, null])"),
+                            this->array(R"([null, null, null, null])"));
+  this->AssertFillNullArray(FillNullBackward,
+                            this->array(R"([null, "40.00", null, null, null])"),
+                            this->array(R"(["40.00", "40.00",null, null, null])"));
+  this->AssertFillNullArray(FillNullBackward,
+                            this->array(R"([null, null, null, "40.00"])"),
+                            this->array(R"(["40.00", "40.00", "40.00", "40.00"])"));
+  this->AssertFillNullArray(FillNullBackward, this->array(R"([null, "40.00", null])"),
+                            this->array(R"(["40.00", "40.00", null])"));
+  this->AssertFillNullArray(FillNullBackward,
+                            this->array(R"([null, null, "40.00", null])"),
+                            this->array(R"(["40.00", "40.00", "40.00", null])"));
+  this->AssertFillNullArray(FillNullBackward,
+                            this->array(R"([null, null, null, "40.00", null])"),
+                            this->array(R"(["40.00", "40.00", "40.00", "40.00", null])"));
+  this->AssertFillNullArray(
+      FillNullBackward, this->array(R"([null, null, "40.00",null, "50.00", null])"),
+      this->array(R"(["40.00", "40.00", "40.00", "50.00", "50.00", null])"));
+
+  this->AssertFillNullArray(FillNullBackward, this->array(R"(["10.00", "40.00", null])"),
+                            this->array(R"(["10.00", "40.00", null])"));
+  this->AssertFillNullArray(FillNullBackward,
+                            this->array(R"(["10.00", "40.00", null, null, null, null])"),
+                            this->array(R"(["10.00", "40.00" ,null, null, null, null])"));
+  this->AssertFillNullArray(
+      FillNullBackward, this->array(R"(["10.00", "40.00", null, "50.00", null, null])"),
+      this->array(R"(["10.00", "40.00" , "50.00", "50.00", null, null])"));
+  this->AssertFillNullArray(
+      FillNullBackward,
+      this->array(R"(["10.00", "40.00", null, "50.00", null, null, "6.00"])"),
+      this->array(R"(["10.00", "40.00" ,"50.00", "50.00", "6.00", "6.00", "6.00"])"));
+  this->AssertFillNullArray(
+      FillNullBackward,
+      this->array(R"(["10.00", "40.00", null, "50.00", null, null, "50.00"])"),
+      this->array(R"(["10.00", "40.00" ,"50.00" , "50.00", "50.00", "50.00", "50.00"])"));
+  this->AssertFillNullArray(
+      FillNullBackward,
+      this->array(R"(["10.00", "40.00", null, "50.00", null, "6.00", null])"),
+      this->array(R"(["10.00", "40.00" ,"50.00" , "50.00", "6.00", "6.00", null])"));
+  this->AssertFillNullArray(
+      FillNullBackward,
+      this->array(R"(["10.00", "40.00", null, "50.00", null, "6.00", "7.00"])"),
+      this->array(R"(["10.00", "40.00" ,"50.00", "50.00", "6.00", "6.00", "7.00"])"));
+  this->AssertFillNullArray(
+      FillNullBackward,
+      this->array(R"(["10.00", "40.00" ,"50.00", "50.00", "6.00", "6.00", "7.00"])"),
+      this->array(R"(["10.00", "40.00" ,"50.00", "50.00", "6.00", "6.00", "7.00"])"));
+}
+
+TYPED_TEST(TestFillNullBinary, FillNullValuesBackward) {
+  this->AssertFillNullArray(FillNullBackward, this->array(R"([])"), this->array(R"([])"));
+
+  this->AssertFillNullArray(FillNullBackward, this->array(R"([null, null, null, null])"),
+                            this->array(R"([null, null, null, null])"));
+  this->AssertFillNullArray(FillNullBackward,
+                            this->array(R"([null, "afd", null, null, null])"),
+                            this->array(R"(["afd", "afd",null, null, null])"));
+  this->AssertFillNullArray(FillNullBackward, this->array(R"([null, null, null, "afd"])"),
+                            this->array(R"(["afd", "afd", "afd", "afd"])"));
+  this->AssertFillNullArray(FillNullBackward, this->array(R"([null, "afd", null])"),
+                            this->array(R"(["afd", "afd", null])"));
+  this->AssertFillNullArray(FillNullBackward, this->array(R"([null, null, "afd", null])"),
+                            this->array(R"(["afd", "afd", "afd", null])"));
+  this->AssertFillNullArray(FillNullBackward,
+                            this->array(R"([null, null, null, "afd", null])"),
+                            this->array(R"(["afd", "afd", "afd", "afd", null])"));
+  this->AssertFillNullArray(FillNullBackward,
+                            this->array(R"([null, null, "afd",null, "qwe", null])"),
+                            this->array(R"(["afd", "afd", "afd", "qwe", "qwe", null])"));
+
+  this->AssertFillNullArray(FillNullBackward, this->array(R"(["tyu", "afd", null])"),
+                            this->array(R"(["tyu", "afd", null])"));
+  this->AssertFillNullArray(FillNullBackward,
+                            this->array(R"(["tyu", "afd", null, null, null, null])"),
+                            this->array(R"(["tyu", "afd" ,null, null, null, null])"));
+  this->AssertFillNullArray(FillNullBackward,
+                            this->array(R"(["tyu", "afd", null, "qwe", null, null])"),
+                            this->array(R"(["tyu", "afd" , "qwe", "qwe", null, null])"));
+  this->AssertFillNullArray(
+      FillNullBackward,
+      this->array(R"(["tyu", "afd", null, "qwe", null, null, "oiutyu"])"),
+      this->array(R"(["tyu", "afd" ,"qwe", "qwe", "oiutyu", "oiutyu", "oiutyu"])"));
+  this->AssertFillNullArray(
+      FillNullBackward, this->array(R"(["tyu", "afd", null, "qwe", null, null, "qwe"])"),
+      this->array(R"(["tyu", "afd" ,"qwe" , "qwe", "qwe", "qwe", "qwe"])"));
+  this->AssertFillNullArray(
+      FillNullBackward,
+      this->array(R"(["tyu", "afd", null, "qwe", null, "oiutyu", null])"),
+      this->array(R"(["tyu", "afd" ,"qwe" , "qwe", "oiutyu", "oiutyu", null])"));
+  this->AssertFillNullArray(
+      FillNullBackward,
+      this->array(R"(["tyu", "afd", null, "qwe", null, "oiutyu", "aaaagggbbb"])"),
+      this->array(R"(["tyu", "afd" ,"qwe", "qwe", "oiutyu", "oiutyu", "aaaagggbbb"])"));
+  this->AssertFillNullArray(
+      FillNullBackward,
+      this->array(R"(["tyu", "afd" ,"qwe", "qwe", "oiutyu", "oiutyu", "aaaagggbbb"])"),
+      this->array(R"(["tyu", "afd" ,"qwe", "qwe", "oiutyu", "oiutyu", "aaaagggbbb"])"));
+}
+
+// For Test Blocks
+TYPED_TEST(TestFillNullNumeric, FillNullForwardLargeInput) {
+  using CType = typename TypeTraits<TypeParam>::CType;
+  random::RandomArrayGenerator rand(/*seed=*/1000);
+  int64_t len_null = 500;
+  int64_t len_random = 1000;
+  std::shared_ptr<Array> array_random =
+      rand.ArrayOf(this->type(), len_random, /*nulls=*/0);
+  auto x_ptr = array_random->data()->template GetValues<CType>(1);
+  ASSERT_OK_AND_ASSIGN(auto array_null, MakeArrayOfNull(array_random->type(), len_null));
+  auto array_null_filled =
+      ConstantArrayGenerator::Numeric<TypeParam>(len_null, x_ptr[len_random - 1]);
+  {
+    ASSERT_OK_AND_ASSIGN(auto value_array,
+                         Concatenate({array_random, array_null, array_random}));
+    ASSERT_OK_AND_ASSIGN(auto result_array,
+                         Concatenate({array_random, array_null_filled, array_random}));
+    this->AssertFillNullArray(FillNullForward, value_array, result_array);
+  }
+}
+
+TYPED_TEST(TestFillNullNumeric, FillNullBackwardLargeInput) {
+  using CType = typename TypeTraits<TypeParam>::CType;
+  random::RandomArrayGenerator rand(/*seed=*/1000);
+  int64_t len_null = 500;
+  int64_t len_random = 1000;
+  std::shared_ptr<Array> array_random =
+      rand.ArrayOf(this->type(), len_random, /*nulls=*/0);
+  auto x_ptr = array_random->data()->template GetValues<CType>(1);
+  ASSERT_OK_AND_ASSIGN(auto array_null, MakeArrayOfNull(array_random->type(), len_null));
+  auto array_null_filled = ConstantArrayGenerator::Numeric<TypeParam>(len_null, x_ptr[0]);
+  {
+    ASSERT_OK_AND_ASSIGN(auto value_array,
+                         Concatenate({array_random, array_null, array_random}));
+    ASSERT_OK_AND_ASSIGN(auto result_array,
+                         Concatenate({array_random, array_null_filled, array_random}));
+    this->AssertFillNullArray(FillNullBackward, value_array, result_array);
+  }
+}
+
+TYPED_TEST(TestFillNullNumeric, FillNullForwardSliced) {
+  auto first_input_array =
+      this->array("[1, 4, null, null, 7, null, null, 8, 9, 5, null]");
+  auto expected_slice_length_2 =
+      this->array("[1, 4, null, null, 7, 7, null, 8, 9, 5, null]");
+  auto expected_slice_length_3 = this->array("[1, 4, 4, null, 7, 7, null, 8, 9, 5, 5]");
+  auto expected_slice_length_4 = this->array("[1, 4, 4, 4, 7, 7, 7, 8, 9, 5, 5]");
+  this->AssertFillNullArraySlices(FillNullForward, first_input_array,
+                                  expected_slice_length_2, expected_slice_length_3,
+                                  expected_slice_length_4);
+}
+
+TYPED_TEST(TestFillNullBinary, FillNullForwardSliced) {
+  auto first_input_array = this->array(
+      R"(["avb", "iyy", null, null, "mnh", null, null, "ttr", "gfd", "lkj", null])");
+  auto expected_slice_length_2 = this->array(
+      R"(["avb", "iyy", null, null, "mnh", "mnh", null, "ttr", "gfd", "lkj", null])");
+  auto expected_slice_length_3 = this->array(
+      R"(["avb", "iyy", "iyy", null, "mnh", "mnh", null, "ttr", "gfd", "lkj", "lkj"])");
+  auto expected_slice_length_4 = this->array(
+      R"(["avb", "iyy", "iyy", "iyy", "mnh", "mnh", "mnh", "ttr", "gfd", "lkj", "lkj"])");
+
+  this->AssertFillNullArraySlices(FillNullForward, first_input_array,
+                                  expected_slice_length_2, expected_slice_length_3,
+                                  expected_slice_length_4);
+}
+
+TYPED_TEST(TestFillNullNumeric, FillNullBackwardSliced) {
+  auto first_input_array =
+      this->array("[1, 4, null, null, 7, null, null, 8, 9, 5, null]");
+  auto expected_slice_length_2 =
+      this->array("[1, 4, null, null, 7, null, 8, 8, 9, 5, null]");
+  auto expected_slice_length_3 =
+      this->array("[1, 4, null, 7, 7, null, 8, 8, 9, 5, null]");
+  auto expected_slice_length_4 =
+      this->array("[1, 4, null, null, 7, 8, 8, 8, 9, 5, null]");
+
+  this->AssertFillNullArraySlices(FillNullBackward, first_input_array,
+                                  expected_slice_length_2, expected_slice_length_3,
+                                  expected_slice_length_4);
+}
+
+TYPED_TEST(TestFillNullBinary, FillNullBackwardSliced) {
+  auto first_input_array = this->array(
+      R"(["tre", "kjh", null, null, "mnb", null, null, "yhn", "ode", "qwe", null])");
+  auto expected_slice_length_2 = this->array(
+      R"(["tre", "kjh", null, null, "mnb", null, "yhn", "yhn", "ode", "qwe", null])");
+  auto expected_slice_length_3 = this->array(
+      R"(["tre", "kjh", null, "mnb", "mnb", null, "yhn", "yhn", "ode", "qwe", null])");
+  auto expected_slice_length_4 = this->array(
+      R"(["tre", "kjh", null, null, "mnb", "yhn", "yhn", "yhn", "ode", "qwe", null])");
+
+  this->AssertFillNullArraySlices(FillNullBackward, first_input_array,
+                                  expected_slice_length_2, expected_slice_length_3,
+                                  expected_slice_length_4);
+}
+
+TYPED_TEST(TestFillNullNumeric, FillNullForwardChunkedArray) {
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array(
+          {"[null, null, null]", "[null, null, null]", "[null]", "[null, null]"}),
+      this->chunked_array(
+          {"[null, null, null]", "[null, null, null]", "[null]", "[null, null]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array(
+          {"[7, null, null]", "[null, null, null]", "[null]", "[null, null]"}),
+      this->chunked_array({"[7, 7, 7]", "[7, 7, 7]", "[7]", "[7, 7]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array(
+          {"[7, null, null]", "[null, null, null]", "[]", "[null, null]"}),
+      this->chunked_array({"[7, 7, 7]", "[7, 7, 7]", "[]", "[7, 7]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array(
+          {"[null, null, null]", "[null, null, null]", "[null]", "[null, 7]"}),
+      this->chunked_array(
+          {"[null, null, null]", "[null, null, null]", "[null]", "[null, 7]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array(
+          {"[null, null, null]", "[8, null, null]", "[null]", "[null, 7]"}),
+      this->chunked_array({"[null, null, null]", "[8, 8, 8]", "[8]", "[8, 7]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array(
+          {"[1, 2, 3, null, null, 4]", "[5, null, null]", "[null, 7, null]"}),
+      this->chunked_array({"[1, 2, 3, 3, 3, 4]", "[5, 5, 5]", "[5, 7, 7]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array(
+          {"[1, 2, 3, null, null, null]", "[null, null, null]", "[null, 7, null]"}),
+      this->chunked_array({"[1, 2, 3, 3, 3, 3]", "[3, 3, 3]", "[3, 7, 7]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array({"[1, 2, null]", "[null, null, null]", "[null]", "[null, 7]"}),
+      this->chunked_array({"[1, 2, 2]", "[2, 2, 2]", "[2]", "[2, 7]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array({"[null, 2, null]", "[null, null, 3]", "[null]", "[null, 7]"}),
+      this->chunked_array({"[null, 2, 2]", "[2, 2, 3]", "[3]", "[3, 7]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array({"[null, 2, null]", "[4, null, 3]", "[null]", "[null, 7]"}),
+      this->chunked_array({"[null, 2, 2]", "[4, 4, 3]", "[3]", "[3, 7]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array({"[null, null, null]", "[null, null, null]", "[5]", "[5, 7]"}),
+      this->chunked_array({"[null, null, null]", "[null, null, null]", "[5]", "[5, 7]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array({"[null, null, 1]", "[null, null, null]", "[5]", "[5, 7]"}),
+      this->chunked_array({"[null, null, 1]", "[1, 1, 1]", "[5]", "[5, 7]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array({"[2, 4, 1]", "[null, null, null]", "[5]", "[5, 7]"}),
+      this->chunked_array({"[2, 4, 1]", "[1, 1, 1]", "[5]", "[5, 7]"}));
+}
+
+TYPED_TEST(TestFillNullBinary, FillNullForwardChunkedArray) {
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array({R"([null, null, null])", R"([null, null, null])", R"([null])",
+                           R"([null, null])"}),
+      this->chunked_array({R"([null, null, null])", R"([null, null, null])", R"([null])",
+                           R"([null, null])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array({R"(["utrmnbv", null, null])", R"([null, null, null])",
+                           R"([null])", R"([null, null])"}),
+      this->chunked_array({R"(["utrmnbv", "utrmnbv", "utrmnbv"])",
+                           R"(["utrmnbv", "utrmnbv", "utrmnbv"])", R"(["utrmnbv"])",
+                           R"(["utrmnbv", "utrmnbv"])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array({R"([null, null, null])", R"([null, null, null])", R"([null])",
+                           R"([null, "utrmnbv"])"}),
+      this->chunked_array({R"([null, null, null])", R"([null, null, null])", R"([null])",
+                           R"([null, "utrmnbv"])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array({R"([null, null, null])", R"(["mnb", null, null])", R"([null])",
+                           R"([null, "utrmnbv"])"}),
+      this->chunked_array({R"([null, null, null])", R"(["mnb", "mnb", "mnb"])",
+                           R"(["mnb"])", R"(["mnb", "utrmnbv"])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array({R"(["aty", "yhh", "puy", null, null, "rwq"])",
+                           R"(["utr", null, null])", R"([null, "utrmnbv", null])"}),
+      this->chunked_array({R"(["aty", "yhh", "puy", "puy", "puy", "rwq"])",
+                           R"(["utr", "utr", "utr"])",
+                           R"(["utr", "utrmnbv", "utrmnbv"])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array({R"(["aty", "yhh", "puy", null, null, null])",
+                           R"([null, null, null])", R"([null, "utrmnbv", null])"}),
+      this->chunked_array({R"(["aty", "yhh", "puy", "puy", "puy", "puy"])",
+                           R"(["puy", "puy", "puy"])",
+                           R"(["puy", "utrmnbv", "utrmnbv"])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array({R"(["aty", "yhh", null])", R"([null, null, null])",
+                           R"([null])", R"([null, "utrmnbv"])"}),
+      this->chunked_array({R"(["aty", "yhh", "yhh"])", R"(["yhh", "yhh", "yhh"])",
+                           R"(["yhh"])", R"(["yhh", "utrmnbv"])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array({R"([null, "yhh", null])", R"([null, null, "puy"])",
+                           R"([null])", R"([null, "utrmnbv"])"}),
+      this->chunked_array({R"([null, "yhh", "yhh"])", R"(["yhh", "yhh", "puy"])",
+                           R"(["puy"])", R"(["puy", "utrmnbv"])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array({R"([null, "yhh", null])", R"(["rwq", null, "puy"])",
+                           R"([null])", R"([null, "utrmnbv"])"}),
+      this->chunked_array({R"([null, "yhh", "yhh"])", R"(["rwq", "rwq", "puy"])",
+                           R"(["puy"])", R"(["puy", "utrmnbv"])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array({R"([null, null, null])", R"([null, null, null])", R"(["utr"])",
+                           R"(["utr", "utrmnbv"])"}),
+      this->chunked_array({R"([null, null, null])", R"([null, null, null])", R"(["utr"])",
+                           R"(["utr", "utrmnbv"])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array({R"([null, null, "aty"])", R"([null, null, null])",
+                           R"(["utr"])", R"(["utr", "utrmnbv"])"}),
+      this->chunked_array({R"([null, null, "aty"])", R"(["aty", "aty", "aty"])",
+                           R"(["utr"])", R"(["utr", "utrmnbv"])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullForward,
+      this->chunked_array({R"(["rt", "tr", "aty"])", R"([null, null, null])",
+                           R"(["utr"])", R"(["utr", "utrmnbv"])"}),
+      this->chunked_array({R"(["rt", "tr", "aty"])", R"(["aty", "aty", "aty"])",
+                           R"(["utr"])", R"(["utr", "utrmnbv"])"}));
+}
+
+TYPED_TEST(TestFillNullNumeric, FillBackwardChunkedArray) {
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array(
+          {"[null, null, null]", "[null, null, null]", "[null]", "[null, null]"}),
+      this->chunked_array(
+          {"[null, null, null]", "[null, null, null]", "[null]", "[null, null]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array(
+          {"[7, null, null]", "[null, null, null]", "[null]", "[null, null]"}),
+      this->chunked_array(
+          {"[7, null, null]", "[null, null, null]", "[null]", "[null, null]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array(
+          {"[null, null, null]", "[null, null, null]", "[null]", "[null, 7]"}),
+      this->chunked_array({"[7, 7, 7]", "[7, 7, 7]", "[7]", "[7, 7]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array(
+          {"[null, null, null]", "[8, null, null]", "[null]", "[null, 7]"}),
+      this->chunked_array({"[8, 8, 8]", "[8, 7, 7]", "[7]", "[7, 7]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array(
+          {"[1, 2, 3, null, null, 4]", "[5, null, null]", "[null, 7, null]"}),
+      this->chunked_array({"[1, 2, 3, 4, 4, 4]", "[5, 7, 7]", "[7, 7, null]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array(
+          {"[1, 2, 3, null, null, null]", "[null, null, null]", "[null, 7, null]"}),
+      this->chunked_array({"[1, 2, 3, 7, 7, 7]", "[7, 7, 7]", "[7, 7, null]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array({"[1, 2, null]", "[null, null, null]", "[null]", "[null, 7]"}),
+      this->chunked_array({"[1, 2, 7]", "[7, 7, 7]", "[7]", "[7, 7]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array({"[null, 2, null]", "[null, null, 3]", "[null]", "[null, 7]"}),
+      this->chunked_array({"[2, 2, 3]", "[3, 3, 3]", "[7]", "[7, 7]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array({"[null, 2, null]", "[4, null, 3]", "[null]", "[null, 7]"}),
+      this->chunked_array({"[2, 2, 4]", "[4, 3, 3]", "[7]", "[7, 7]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array({"[null, null, null]", "[null, null, null]", "[5]", "[5, 7]"}),
+      this->chunked_array({"[5, 5, 5]", "[5, 5, 5]", "[5]", "[5, 7]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array({"[null, null, 1]", "[null, null, null]", "[5]", "[5, 7]"}),
+      this->chunked_array({"[1, 1, 1]", "[5, 5, 5]", "[5]", "[5, 7]"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array({"[null, null, 1]", "[null, null, null]", "[9, 0]", "[5, 7]"}),
+      this->chunked_array({"[1, 1, 1]", "[9, 9, 9]", "[9, 0]", "[5, 7]"}));
+}
+
+TYPED_TEST(TestFillNullBinary, FillBackwardChunkedArray) {
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array({R"([null, null, null])", R"([null, null, null])", R"([null])",
+                           R"([null, null])"}),
+      this->chunked_array({R"([null, null, null])", R"([null, null, null])", R"([null])",
+                           R"([null, null])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array({R"(["mnz", null, null])", R"([null, null, null])", R"([null])",
+                           R"([null, null])"}),
+      this->chunked_array({R"(["mnz", null, null])", R"([null, null, null])", R"([null])",
+                           R"([null, null])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array({R"([null, null, null])", R"([null, null, null])", R"([null])",
+                           R"([null, "mnz"])"}),
+      this->chunked_array({R"(["mnz", "mnz", "mnz"])", R"(["mnz", "mnz", "mnz"])",
+                           R"(["mnz"])", R"(["mnz", "mnz"])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array({R"([null, null, null])", R"(["qwer", null, null])",
+                           R"([null])", R"([null, "mnz"])"}),
+      this->chunked_array({R"(["qwer", "qwer", "qwer"])", R"(["qwer", "mnz", "mnz"])",
+                           R"(["mnz"])", R"(["mnz", "mnz"])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array({R"(["tre", "vda", "bvf", null, null, "poi"])",
+                           R"(["qup", null, null])", R"([null, "mnz", null])"}),
+      this->chunked_array({R"(["tre", "vda", "bvf", "poi", "poi", "poi"])",
+                           R"(["qup", "mnz", "mnz"])", R"(["mnz", "mnz", null])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array({R"(["tre", "vda", "bvf", null, null, null])",
+                           R"([null, null, null])", R"([null, "mnz", null])"}),
+      this->chunked_array({R"(["tre", "vda", "bvf", "mnz", "mnz", "mnz"])",
+                           R"(["mnz", "mnz", "mnz"])", R"(["mnz", "mnz", null])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array({R"(["tre", "vda", null])", R"([null, null, null])",
+                           R"([null])", R"([null, "mnz"])"}),
+      this->chunked_array({R"(["tre", "vda", "mnz"])", R"(["mnz", "mnz", "mnz"])",
+                           R"(["mnz"])", R"(["mnz", "mnz"])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array({R"([null, "vda", null])", R"([null, null, "bvf"])",
+                           R"([null])", R"([null, "mnz"])"}),
+      this->chunked_array({R"(["vda", "vda", "bvf"])", R"(["bvf", "bvf", "bvf"])",
+                           R"(["mnz"])", R"(["mnz", "mnz"])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array({R"([null, "vda", null])", R"(["poi", null, "bvf"])",
+                           R"([null])", R"([null, "mnz"])"}),
+      this->chunked_array({R"(["vda", "vda", "poi"])", R"(["poi", "bvf", "bvf"])",
+                           R"(["mnz"])", R"(["mnz", "mnz"])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array({R"([null, null, null])", R"([null, null, null])", R"(["qup"])",
+                           R"(["qup", "mnz"])"}),
+      this->chunked_array({R"(["qup", "qup", "qup"])", R"(["qup", "qup", "qup"])",
+                           R"(["qup"])", R"(["qup", "mnz"])"}));
+  this->AssertFillNullChunkedArray(
+      FillNullBackward,
+      this->chunked_array({R"([null, null, "tre"])", R"([null, null, null])",
+                           R"(["qup"])", R"(["qup", "mnz"])"}),
+      this->chunked_array({R"(["tre", "tre", "tre"])", R"(["qup", "qup", "qup"])",
+                           R"(["qup"])", R"(["qup", "mnz"])"}));
+}
+
+TEST_F(TestFillNullType, TestFillOnNullType) {
+  this->AssertFillNullArray(FillNullForward, this->array(R"([null, null, null, null])"),
+                            this->array(R"([null, null, null, null])"));
+  this->AssertFillNullArray(FillNullForward, this->array(R"([null])"),
+                            this->array(R"([null])"));
+  this->AssertFillNullArray(FillNullForward, this->array(R"([null, null])"),
+                            this->array(R"([null, null])"));
+  this->AssertFillNullArray(FillNullBackward, this->array(R"([null, null, null, null])"),
+                            this->array(R"([null, null, null, null])"));
+  this->AssertFillNullArray(FillNullBackward, this->array(R"([null])"),
+                            this->array(R"([null])"));
+  this->AssertFillNullArray(FillNullBackward, this->array(R"([null, null])"),
+                            this->array(R"([null, null])"));
+}
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/testing/generator.h b/cpp/src/arrow/testing/generator.h
index 9d9ed1a5772..3a70659293c 100644
--- a/cpp/src/arrow/testing/generator.h
+++ b/cpp/src/arrow/testing/generator.h
@@ -22,6 +22,7 @@
 #include <string>
 #include <vector>
 
+#include "arrow/array/array_base.h"
 #include "arrow/testing/gtest_util.h"
 #include "arrow/testing/visibility.h"
 #include "arrow/type_fwd.h"
@@ -151,6 +152,40 @@ class ARROW_TESTING_EXPORT ConstantArrayGenerator {
         return Float32(size, static_cast<float>(value));
       case Type::DOUBLE:
         return Float64(size, static_cast<double>(value));
+      case Type::INTERVAL_DAY_TIME:
+      case Type::DATE32: {
+        EXPECT_OK_AND_ASSIGN(auto viewed,
+                             Int32(size, static_cast<uint32_t>(value))->View(date32()));
+        return viewed;
+      }
+      case Type::INTERVAL_MONTHS: {
+        EXPECT_OK_AND_ASSIGN(auto viewed,
+                             Int32(size, static_cast<uint32_t>(value))
+                                 ->View(std::make_shared<MonthIntervalType>()));
+        return viewed;
+      }
+      case Type::TIME32: {
+        EXPECT_OK_AND_ASSIGN(auto viewed,
+                             Int32(size, static_cast<uint32_t>(value))
+                                 ->View(std::make_shared<Time32Type>(TimeUnit::SECOND)));
+        return viewed;
+      }
+      case Type::TIME64: {
+        EXPECT_OK_AND_ASSIGN(auto viewed, Int64(size, static_cast<uint64_t>(value))
+                                              ->View(std::make_shared<Time64Type>()));
+        return viewed;
+      }
+      case Type::DATE64: {
+        EXPECT_OK_AND_ASSIGN(auto viewed,
+                             Int64(size, static_cast<uint64_t>(value))->View(date64()));
+        return viewed;
+      }
+      case Type::TIMESTAMP: {
+        EXPECT_OK_AND_ASSIGN(
+            auto viewed, Int64(size, static_cast<int64_t>(value))
+                             ->View(std::make_shared<TimestampType>(TimeUnit::SECOND)));
+        return viewed;
+      }
       default:
         return nullptr;
     }
diff --git a/cpp/src/arrow/util/bit_util_test.cc b/cpp/src/arrow/util/bit_util_test.cc
index e3e5d960bdb..83f00afc9d0 100644
--- a/cpp/src/arrow/util/bit_util_test.cc
+++ b/cpp/src/arrow/util/bit_util_test.cc
@@ -64,6 +64,7 @@ using internal::BitsetStack;
 using internal::CopyBitmap;
 using internal::CountSetBits;
 using internal::InvertBitmap;
+using internal::ReverseBitmap;
 using util::SafeCopy;
 
 using ::testing::ElementsAreArray;
@@ -1683,6 +1684,46 @@ TEST(BitUtilTests, TestCopyAndInvertBitmapPreAllocated) {
   }
 }
 
+TEST(BitUtilTests, TestCopyAndReverseBitmapPreAllocated) {
+  const int kBufferSize = 1000;
+  std::vector<int64_t> lengths = {kBufferSize * 8 - 4, kBufferSize * 8};
+  std::vector<int64_t> offsets = {0, 12, 16, 32, 37, 63, 64, 128};
+
+  ASSERT_OK_AND_ASSIGN(auto buffer, AllocateBuffer(kBufferSize));
+  memset(buffer->mutable_data(), 0, kBufferSize);
+  random_bytes(kBufferSize, 0, buffer->mutable_data());
+  const uint8_t* src = buffer->data();
+
+  // Add 16 byte padding on both sides
+  ASSERT_OK_AND_ASSIGN(auto other_buffer, AllocateBuffer(kBufferSize + 32));
+  memset(other_buffer->mutable_data(), 0, kBufferSize + 32);
+  random_bytes(kBufferSize + 32, 0, other_buffer->mutable_data());
+  const uint8_t* other = other_buffer->data();
+
+  for (int64_t num_bits : lengths) {
+    for (int64_t offset : offsets) {
+      for (int64_t dest_offset : offsets) {
+        const int64_t copy_length = num_bits - offset;
+
+        ASSERT_OK_AND_ASSIGN(auto copy, AllocateBuffer(other_buffer->size()));
+        memcpy(copy->mutable_data(), other_buffer->data(), other_buffer->size());
+        ReverseBitmap(src, offset, copy_length, copy->mutable_data(), dest_offset);
+
+        for (int64_t i = 0; i < dest_offset; ++i) {
+          ASSERT_EQ(bit_util::GetBit(other, i), bit_util::GetBit(copy->data(), i));
+        }
+        for (int64_t i = 0; i < copy_length; ++i) {
+          ASSERT_EQ(bit_util::GetBit(src, offset + i),
+                    bit_util::GetBit(copy->data(), dest_offset + (copy_length - 1) - i));
+        }
+        for (int64_t i = dest_offset + copy_length; i < (other_buffer->size() * 8); ++i) {
+          ASSERT_EQ(bit_util::GetBit(other, i), bit_util::GetBit(copy->data(), i));
+        }
+      }
+    }
+  }
+}
+
 TEST(BitUtilTests, TestBitmapEquals) {
   const int srcBufferSize = 1000;
 
diff --git a/cpp/src/arrow/util/bitmap_ops.cc b/cpp/src/arrow/util/bitmap_ops.cc
index 33290fa4dfc..ad51a6dc733 100644
--- a/cpp/src/arrow/util/bitmap_ops.cc
+++ b/cpp/src/arrow/util/bitmap_ops.cc
@@ -86,6 +86,21 @@ int64_t CountSetBits(const uint8_t* data, int64_t bit_offset, int64_t length) {
 
 enum class TransferMode : bool { Copy, Invert };
 
+// Reverse all bits from entire byte(uint8)
+uint8_t ReverseUint8(uint8_t num) {
+  num = ((num & 0xf0) >> 4) | ((num & 0x0f) << 4);
+  num = ((num & 0xcc) >> 2) | ((num & 0x33) << 2);
+  num = ((num & 0xaa) >> 1) | ((num & 0x55) << 1);
+  return num;
+}
+
+// Get a reverse block of byte(uint8) using offsets, the result can be
+// part of a left block and right block, length indicates the number of bits
+// to be taken from the right block
+uint8_t GetReversedBlock(uint8_t block_left, uint8_t block_right, uint8_t length) {
+  return ReverseUint8(block_left >> (length) | block_right << (8 - length));
+}
+
 template <TransferMode mode>
 void TransferBitmap(const uint8_t* data, int64_t offset, int64_t length,
                     int64_t dest_offset, uint8_t* dest) {
@@ -138,6 +153,49 @@ void TransferBitmap(const uint8_t* data, int64_t offset, int64_t length,
   }
 }
 
+void ReverseBlockOffsets(const uint8_t* data, int64_t offset, int64_t length,
+                         int64_t dest_offset, uint8_t* dest) {
+  int64_t num_bytes = bit_util::BytesForBits(offset % 8 + length);
+  // Shift by its byte offset
+  data += offset / 8;
+  dest += dest_offset / 8;
+
+  int64_t j_src = num_bytes - 1;
+  int64_t i_dest = 0;
+
+  while (length > 0) {
+    uint8_t right_trailing_bits_src = (length + offset) % 8;
+    right_trailing_bits_src = !right_trailing_bits_src ? 8 : right_trailing_bits_src;
+
+    uint8_t left_trailing_bits_dest = 8 - dest_offset % 8;
+    uint8_t left_trailing_mask_dest = 0xFF << (8 - left_trailing_bits_dest);
+    if (length <= 8 && (dest_offset % 8) + length < 8) {
+      uint8_t extra_bits = static_cast<uint8_t>(8 - ((dest_offset % 8) + length));
+      left_trailing_mask_dest <<= extra_bits;
+      left_trailing_mask_dest >>= extra_bits;
+    }
+
+    uint8_t right_reversed_block;
+    if (j_src == 0) {
+      right_reversed_block = static_cast<uint8_t>(
+          GetReversedBlock(data[0], data[0], right_trailing_bits_src));
+    } else {
+      right_reversed_block = static_cast<uint8_t>(
+          GetReversedBlock(data[j_src - 1], data[j_src], right_trailing_bits_src));
+    }
+
+    dest[i_dest] &= ~left_trailing_mask_dest;
+    dest[i_dest] |=
+        (right_reversed_block << (8 - left_trailing_bits_dest)) & left_trailing_mask_dest;
+
+    dest_offset += left_trailing_bits_dest;
+    length -= left_trailing_bits_dest;
+
+    if (left_trailing_bits_dest >= right_trailing_bits_src) j_src--;
+    i_dest++;
+  }
+}
+
 template <TransferMode mode>
 Result<std::shared_ptr<Buffer>> TransferBitmap(MemoryPool* pool, const uint8_t* data,
                                                int64_t offset, int64_t length) {
@@ -167,6 +225,11 @@ void InvertBitmap(const uint8_t* data, int64_t offset, int64_t length, uint8_t*
   TransferBitmap<TransferMode::Invert>(data, offset, length, dest_offset, dest);
 }
 
+void ReverseBitmap(const uint8_t* data, int64_t offset, int64_t length, uint8_t* dest,
+                   int64_t dest_offset) {
+  ReverseBlockOffsets(data, offset, length, dest_offset, dest);
+}
+
 Result<std::shared_ptr<Buffer>> CopyBitmap(MemoryPool* pool, const uint8_t* data,
                                            int64_t offset, int64_t length) {
   return TransferBitmap<TransferMode::Copy>(pool, data, offset, length);
@@ -177,6 +240,16 @@ Result<std::shared_ptr<Buffer>> InvertBitmap(MemoryPool* pool, const uint8_t* da
   return TransferBitmap<TransferMode::Invert>(pool, data, offset, length);
 }
 
+Result<std::shared_ptr<Buffer>> ReverseBitmap(MemoryPool* pool, const uint8_t* data,
+                                              int64_t offset, int64_t length) {
+  ARROW_ASSIGN_OR_RAISE(auto buffer, AllocateEmptyBitmap(length, pool));
+  uint8_t* dest = buffer->mutable_data();
+
+  ReverseBlockOffsets(data, offset, length, /*start_offset=*/0, dest);
+
+  return buffer;
+}
+
 bool BitmapEquals(const uint8_t* left, int64_t left_offset, const uint8_t* right,
                   int64_t right_offset, int64_t length) {
   if (left_offset % 8 == 0 && right_offset % 8 == 0) {
diff --git a/cpp/src/arrow/util/bitmap_ops.h b/cpp/src/arrow/util/bitmap_ops.h
index 40a7797a239..8ba84dce4a7 100644
--- a/cpp/src/arrow/util/bitmap_ops.h
+++ b/cpp/src/arrow/util/bitmap_ops.h
@@ -81,6 +81,30 @@ ARROW_EXPORT
 Result<std::shared_ptr<Buffer>> InvertBitmap(MemoryPool* pool, const uint8_t* bitmap,
                                              int64_t offset, int64_t length);
 
+/// Reverse a bit range of an existing bitmap into an existing bitmap
+///
+/// \param[in] bitmap source data
+/// \param[in] offset bit offset into the source data
+/// \param[in] length number of bits to reverse
+/// \param[in] dest_offset bit offset into the destination
+/// \param[out] dest the destination buffer, must have at least space for
+/// (offset + length) bits
+ARROW_EXPORT
+void ReverseBitmap(const uint8_t* bitmap, int64_t offset, int64_t length, uint8_t* dest,
+                   int64_t dest_offset);
+
+/// Reverse a bit range of an existing bitmap
+///
+/// \param[in] pool memory pool to allocate memory from
+/// \param[in] bitmap source data
+/// \param[in] offset bit offset into the source data
+/// \param[in] length number of bits to reverse
+///
+/// \return Status message
+ARROW_EXPORT
+Result<std::shared_ptr<Buffer>> ReverseBitmap(MemoryPool* pool, const uint8_t* bitmap,
+                                              int64_t offset, int64_t length);
+
 /// Compute the number of 1's in the given data array
 ///
 /// \param[in] data a packed LSB-ordered bitmap as a byte array