diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index b7287129cbc13..d992d073d518a 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -98,6 +98,44 @@ struct EnumTraits<compute::CompareOperator>
     return "<INVALID>";
   }
 };
+template <>
+struct EnumTraits<compute::AssumeTimezoneOptions::Ambiguous>
+    : BasicEnumTraits<compute::AssumeTimezoneOptions::Ambiguous,
+                      compute::AssumeTimezoneOptions::Ambiguous::AMBIGUOUS_RAISE,
+                      compute::AssumeTimezoneOptions::Ambiguous::AMBIGUOUS_EARLIEST,
+                      compute::AssumeTimezoneOptions::Ambiguous::AMBIGUOUS_LATEST> {
+  static std::string name() { return "AssumeTimezoneOptions::Ambiguous"; }
+  static std::string value_name(compute::AssumeTimezoneOptions::Ambiguous value) {
+    switch (value) {
+      case compute::AssumeTimezoneOptions::Ambiguous::AMBIGUOUS_RAISE:
+        return "AMBIGUOUS_RAISE";
+      case compute::AssumeTimezoneOptions::Ambiguous::AMBIGUOUS_EARLIEST:
+        return "AMBIGUOUS_EARLIEST";
+      case compute::AssumeTimezoneOptions::Ambiguous::AMBIGUOUS_LATEST:
+        return "AMBIGUOUS_LATEST";
+    }
+    return "<INVALID>";
+  }
+};
+template <>
+struct EnumTraits<compute::AssumeTimezoneOptions::Nonexistent>
+    : BasicEnumTraits<compute::AssumeTimezoneOptions::Nonexistent,
+                      compute::AssumeTimezoneOptions::Nonexistent::NONEXISTENT_RAISE,
+                      compute::AssumeTimezoneOptions::Nonexistent::NONEXISTENT_EARLIEST,
+                      compute::AssumeTimezoneOptions::Nonexistent::NONEXISTENT_LATEST> {
+  static std::string name() { return "AssumeTimezoneOptions::Nonexistent"; }
+  static std::string value_name(compute::AssumeTimezoneOptions::Nonexistent value) {
+    switch (value) {
+      case compute::AssumeTimezoneOptions::Nonexistent::NONEXISTENT_RAISE:
+        return "NONEXISTENT_RAISE";
+      case compute::AssumeTimezoneOptions::Nonexistent::NONEXISTENT_EARLIEST:
+        return "NONEXISTENT_EARLIEST";
+      case compute::AssumeTimezoneOptions::Nonexistent::NONEXISTENT_LATEST:
+        return "NONEXISTENT_LATEST";
+    }
+    return "<INVALID>";
+  }
+};
 }  // namespace internal
 
 namespace compute {
@@ -147,6 +185,10 @@ static auto kStrptimeOptionsType = GetFunctionOptionsType<StrptimeOptions>(
     DataMember("unit", &StrptimeOptions::unit));
 static auto kStrftimeOptionsType = GetFunctionOptionsType<StrftimeOptions>(
     DataMember("format", &StrftimeOptions::format));
+static auto kAssumeTimezoneOptionsType = GetFunctionOptionsType<AssumeTimezoneOptions>(
+    DataMember("timezone", &AssumeTimezoneOptions::timezone),
+    DataMember("ambiguous", &AssumeTimezoneOptions::ambiguous),
+    DataMember("nonexistent", &AssumeTimezoneOptions::nonexistent));
 static auto kPadOptionsType = GetFunctionOptionsType<PadOptions>(
     DataMember("width", &PadOptions::width), DataMember("padding", &PadOptions::padding));
 static auto kTrimOptionsType = GetFunctionOptionsType<TrimOptions>(
@@ -250,6 +292,15 @@ StrftimeOptions::StrftimeOptions() : StrftimeOptions(kDefaultFormat) {}
 constexpr char StrftimeOptions::kTypeName[];
 constexpr const char* StrftimeOptions::kDefaultFormat;
 
+AssumeTimezoneOptions::AssumeTimezoneOptions(std::string timezone, Ambiguous ambiguous,
+                                             Nonexistent nonexistent)
+    : FunctionOptions(internal::kAssumeTimezoneOptionsType),
+      timezone(std::move(timezone)),
+      ambiguous(ambiguous),
+      nonexistent(nonexistent) {}
+AssumeTimezoneOptions::AssumeTimezoneOptions() : AssumeTimezoneOptions("UTC") {}
+constexpr char AssumeTimezoneOptions::kTypeName[];
+
 PadOptions::PadOptions(int64_t width, std::string padding)
     : FunctionOptions(internal::kPadOptionsType),
       width(width),
@@ -311,6 +362,7 @@ void RegisterScalarOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kSetLookupOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kStrptimeOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kStrftimeOptionsType));
+  DCHECK_OK(registry->AddFunctionOptionsType(kAssumeTimezoneOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kPadOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kTrimOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kSliceOptionsType));
@@ -512,6 +564,11 @@ Result<Datum> DayOfWeek(const Datum& arg, DayOfWeekOptions options, ExecContext*
   return CallFunction("day_of_week", {arg}, &options, ctx);
 }
 
+Result<Datum> AssumeTimezone(const Datum& arg, AssumeTimezoneOptions options,
+                             ExecContext* ctx) {
+  return CallFunction("assume_timezone", {arg}, &options, ctx);
+}
+
 Result<Datum> Strftime(const Datum& arg, StrftimeOptions options, ExecContext* ctx) {
   return CallFunction("strftime", {arg}, &options, ctx);
 }
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index e959884b23320..c50803a045691 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -29,6 +29,7 @@
 #include "arrow/result.h"
 #include "arrow/util/macros.h"
 #include "arrow/util/visibility.h"
+#include "arrow/vendored/datetime.h"
 
 namespace arrow {
 namespace compute {
@@ -278,6 +279,40 @@ struct ARROW_EXPORT DayOfWeekOptions : public FunctionOptions {
   uint32_t week_start;
 };
 
+/// Used to control timestamp timezone conversion and handling ambiguous/nonexistent
+/// times.
+struct ARROW_EXPORT AssumeTimezoneOptions : public FunctionOptions {
+ public:
+  /// \brief How to interpret ambiguous local times that can be interpreted as
+  /// multiple instants (normally two) due to DST shifts.
+  ///
+  /// AMBIGUOUS_EARLIEST emits the earliest instant amongst possible interpretations.
+  /// AMBIGUOUS_LATEST emits the latest instant amongst possible interpretations.
+  enum Ambiguous { AMBIGUOUS_RAISE, AMBIGUOUS_EARLIEST, AMBIGUOUS_LATEST };
+
+  /// \brief How to handle local times that do not exist due to DST shifts.
+  ///
+  /// NONEXISTENT_EARLIEST emits the instant "just before" the DST shift instant
+  /// in the given timestamp precision (for example, for a nanoseconds precision
+  /// timestamp, this is one nanosecond before the DST shift instant).
+  /// NONEXISTENT_LATEST emits the DST shift instant.
+  enum Nonexistent { NONEXISTENT_RAISE, NONEXISTENT_EARLIEST, NONEXISTENT_LATEST };
+
+  explicit AssumeTimezoneOptions(std::string timezone,
+                                 Ambiguous ambiguous = AMBIGUOUS_RAISE,
+                                 Nonexistent nonexistent = NONEXISTENT_RAISE);
+  AssumeTimezoneOptions();
+  constexpr static char const kTypeName[] = "AssumeTimezoneOptions";
+
+  /// Timezone to convert timestamps from
+  std::string timezone;
+
+  /// How to interpret ambiguous local times (due to DST shifts)
+  Ambiguous ambiguous;
+  /// How to interpret non-existent local times (due to DST shifts)
+  Nonexistent nonexistent;
+};
+
 /// @}
 
 /// \brief Get the absolute value of a value.
@@ -1025,5 +1060,21 @@ ARROW_EXPORT Result<Datum> Subsecond(const Datum& values, ExecContext* ctx = NUL
 ARROW_EXPORT Result<Datum> Strftime(const Datum& values, StrftimeOptions options,
                                     ExecContext* ctx = NULLPTR);
 
+/// \brief Converts timestamps from local timestamp without a timezone to a timestamp with
+/// timezone, interpreting the local timestamp as being in the specified timezone for each
+/// element of `values`
+///
+/// \param[in] values input to convert
+/// \param[in] options for setting source timezone, exception and ambiguous timestamp
+/// handling.
+/// \param[in] ctx the function execution context, optional
+/// \return the resulting datum
+///
+/// \since 6.0.0
+/// \note API not yet finalized
+ARROW_EXPORT Result<Datum> AssumeTimezone(const Datum& values,
+                                          AssumeTimezoneOptions options,
+                                          ExecContext* ctx = NULLPTR);
+
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/function_test.cc b/cpp/src/arrow/compute/function_test.cc
index d7ebdf3de1d31..ab41887ca35fb 100644
--- a/cpp/src/arrow/compute/function_test.cc
+++ b/cpp/src/arrow/compute/function_test.cc
@@ -15,17 +15,18 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include "arrow/compute/function.h"
+
+#include <gtest/gtest.h>
+
 #include <memory>
 #include <string>
 #include <vector>
 
-#include <gtest/gtest.h>
-
 #include "arrow/compute/api_aggregate.h"
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/api_vector.h"
 #include "arrow/compute/cast.h"
-#include "arrow/compute/function.h"
 #include "arrow/compute/kernel.h"
 #include "arrow/datum.h"
 #include "arrow/status.h"
@@ -80,6 +81,11 @@ TEST(FunctionOptions, Equality) {
   options.emplace_back(new StrptimeOptions("%Y", TimeUnit::type::MILLI));
   options.emplace_back(new StrptimeOptions("%Y", TimeUnit::type::NANO));
   options.emplace_back(new StrftimeOptions("%Y-%m-%dT%H:%M:%SZ", "C"));
+#ifndef _WIN32
+  options.emplace_back(new AssumeTimezoneOptions(
+      "Europe/Amsterdam", AssumeTimezoneOptions::Ambiguous::AMBIGUOUS_RAISE,
+      AssumeTimezoneOptions::Nonexistent::NONEXISTENT_RAISE));
+#endif
   options.emplace_back(new PadOptions(5, " "));
   options.emplace_back(new PadOptions(10, "A"));
   options.emplace_back(new TrimOptions(" "));
diff --git a/cpp/src/arrow/compute/kernel.h b/cpp/src/arrow/compute/kernel.h
index 099bd95bbf238..01750d1f35919 100644
--- a/cpp/src/arrow/compute/kernel.h
+++ b/cpp/src/arrow/compute/kernel.h
@@ -290,9 +290,11 @@ class ARROW_EXPORT OutputType {
   enum ResolveKind { FIXED, COMPUTED };
 
   /// Type resolution function. Given input types and shapes, return output
-  /// type and shape. This function SHOULD _not_ be used to check for arity,
-  /// that is to be performed one or more layers above. May make use of kernel
-  /// state to know what type to output in some cases.
+  /// type and shape.  This function MAY may use the kernel state to decide
+  /// the output type based on the functionoptions.
+  ///
+  /// This function SHOULD _not_ be used to check for arity, that is to be
+  /// performed one or more layers above.
   using Resolver =
       std::function<Result<ValueDescr>(KernelContext*, const std::vector<ValueDescr>&)>;
 
@@ -304,7 +306,8 @@ class ARROW_EXPORT OutputType {
   /// \brief Output the exact type and shape provided by a ValueDescr
   OutputType(ValueDescr descr);  // NOLINT implicit construction
 
-  explicit OutputType(Resolver resolver)
+  /// \brief Output a computed type depending on actual input types
+  OutputType(Resolver resolver)  // NOLINT implicit construction
       : kind_(COMPUTED), resolver_(std::move(resolver)) {}
 
   OutputType(const OutputType& other) {
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index b60e4ef71f0c9..bb67489690ea8 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -16,6 +16,7 @@
 // under the License.
 
 #include <cmath>
+#include <initializer_list>
 #include <sstream>
 
 #include "arrow/builder.h"
@@ -49,6 +50,7 @@ using arrow_vendored::date::weekday;
 using arrow_vendored::date::weeks;
 using arrow_vendored::date::year_month_day;
 using arrow_vendored::date::years;
+using arrow_vendored::date::zoned_time;
 using arrow_vendored::date::literals::dec;
 using arrow_vendored::date::literals::jan;
 using arrow_vendored::date::literals::last;
@@ -59,6 +61,7 @@ using internal::applicator::SimpleUnary;
 
 using DayOfWeekState = OptionsWrapper<DayOfWeekOptions>;
 using StrftimeState = OptionsWrapper<StrftimeOptions>;
+using AssumeTimezoneState = OptionsWrapper<AssumeTimezoneOptions>;
 
 const std::shared_ptr<DataType>& IsoCalendarType() {
   static auto type = struct_({field("iso_year", int64()), field("iso_week", int64()),
@@ -205,6 +208,28 @@ struct TemporalComponentExtractDayOfWeek
   }
 };
 
+template <template <typename...> class Op, typename Duration, typename InType,
+          typename OutType>
+struct AssumeTimezoneExtractor
+    : public TemporalComponentExtractBase<Op, Duration, InType, OutType> {
+  using Base = TemporalComponentExtractBase<Op, Duration, InType, OutType>;
+
+  static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+    const AssumeTimezoneOptions& options = AssumeTimezoneState::Get(ctx);
+    const auto& timezone = GetInputTimezone(batch.values[0]);
+    if (!timezone.empty()) {
+      return Status::Invalid("Timestamps already have a timezone: '", timezone,
+                             "'. Cannot localize to '", options.timezone, "'.");
+    }
+    ARROW_ASSIGN_OR_RAISE(auto tz, LocateZone(options.timezone));
+    using ExecTemplate = Op<Duration>;
+    auto op = ExecTemplate(&options, tz);
+    applicator::ScalarUnaryNotNullStateful<OutType, TimestampType, ExecTemplate> kernel{
+        op};
+    return kernel.Exec(ctx, batch, out);
+  }
+};
+
 // ----------------------------------------------------------------------
 // Extract year from temporal types
 //
@@ -578,8 +603,7 @@ struct Strftime {
 
     Result<std::string> operator()(int64_t arg) {
       bufstream.str("");
-      const auto zt = arrow_vendored::date::zoned_time<Duration>{
-          tz, sys_time<Duration>(Duration{arg})};
+      const auto zt = zoned_time<Duration>{tz, sys_time<Duration>(Duration{arg})};
       try {
         arrow_vendored::date::to_stream(bufstream, format, zt);
       } catch (const std::runtime_error& ex) {
@@ -591,7 +615,6 @@ struct Strftime {
     }
   };
 };
-
 #else
 template <typename Duration, typename InType>
 struct Strftime {
@@ -605,7 +628,82 @@ struct Strftime {
 #endif
 
 // ----------------------------------------------------------------------
-// Extract ISO calendar values from temporal types
+// Convert timestamps from local timestamp without a timezone to timestamps with a
+// timezone, interpreting the local timestamp as being in the specified timezone
+
+Result<ValueDescr> ResolveAssumeTimezoneOutput(KernelContext* ctx,
+                                               const std::vector<ValueDescr>& args) {
+  auto in_type = checked_cast<const TimestampType*>(args[0].type.get());
+  auto type = timestamp(in_type->unit(), AssumeTimezoneState::Get(ctx).timezone);
+  return ValueDescr(std::move(type));
+}
+
+template <typename Duration>
+struct AssumeTimezone {
+  explicit AssumeTimezone(const AssumeTimezoneOptions* options, const time_zone* tz)
+      : options(*options), tz_(tz) {}
+
+  template <typename T, typename Arg0>
+  T get_local_time(Arg0 arg, const time_zone* tz) const {
+    return static_cast<T>(zoned_time<Duration>(tz, local_time<Duration>(Duration{arg}))
+                              .get_sys_time()
+                              .time_since_epoch()
+                              .count());
+  }
+
+  template <typename T, typename Arg0>
+  T get_local_time(Arg0 arg, const arrow_vendored::date::choose choose,
+                   const time_zone* tz) const {
+    return static_cast<T>(
+        zoned_time<Duration>(tz, local_time<Duration>(Duration{arg}), choose)
+            .get_sys_time()
+            .time_since_epoch()
+            .count());
+  }
+
+  template <typename T, typename Arg0>
+  T Call(KernelContext*, Arg0 arg, Status* st) const {
+    try {
+      return get_local_time<T, Arg0>(arg, tz_);
+    } catch (const arrow_vendored::date::nonexistent_local_time& e) {
+      switch (options.nonexistent) {
+        case AssumeTimezoneOptions::Nonexistent::NONEXISTENT_RAISE: {
+          *st = Status::Invalid("Timestamp doesn't exist in timezone '", options.timezone,
+                                "': ", e.what());
+          return arg;
+        }
+        case AssumeTimezoneOptions::Nonexistent::NONEXISTENT_EARLIEST: {
+          return get_local_time<T, Arg0>(arg, arrow_vendored::date::choose::latest, tz_) -
+                 1;
+        }
+        case AssumeTimezoneOptions::Nonexistent::NONEXISTENT_LATEST: {
+          return get_local_time<T, Arg0>(arg, arrow_vendored::date::choose::latest, tz_);
+        }
+      }
+    } catch (const arrow_vendored::date::ambiguous_local_time& e) {
+      switch (options.ambiguous) {
+        case AssumeTimezoneOptions::Ambiguous::AMBIGUOUS_RAISE: {
+          *st = Status::Invalid("Timestamp is ambiguous in timezone '", options.timezone,
+                                "': ", e.what());
+          return arg;
+        }
+        case AssumeTimezoneOptions::Ambiguous::AMBIGUOUS_EARLIEST: {
+          return get_local_time<T, Arg0>(arg, arrow_vendored::date::choose::earliest,
+                                         tz_);
+        }
+        case AssumeTimezoneOptions::Ambiguous::AMBIGUOUS_LATEST: {
+          return get_local_time<T, Arg0>(arg, arrow_vendored::date::choose::latest, tz_);
+        }
+      }
+    }
+    return 0;
+  }
+  AssumeTimezoneOptions options;
+  const time_zone* tz_;
+};
+
+// ----------------------------------------------------------------------
+// Extract ISO calendar values from timestamp
 
 template <typename Duration, typename Localizer>
 inline std::array<int64_t, 3> GetIsoCalendar(int64_t arg, Localizer&& localizer) {
@@ -737,102 +835,120 @@ struct ISOCalendar {
   }
 };
 
+// Which types to generate a kernel for
+enum EnabledTypes : uint8_t { WithDates, WithTimestamps };
+
 template <template <typename...> class Op,
           template <template <typename...> class OpExec, typename Duration,
                     typename InType, typename OutType>
           class ExecTemplate,
           typename OutType>
 std::shared_ptr<ScalarFunction> MakeTemporal(
-    bool enable_date, std::string name, const std::shared_ptr<arrow::DataType> out_type,
+    std::string name, std::initializer_list<EnabledTypes> in_types, OutputType out_type,
     const FunctionDoc* doc, const FunctionOptions* default_options = NULLPTR,
     KernelInit init = NULLPTR) {
+  DCHECK_NE(in_types.size(), 0);
   auto func =
       std::make_shared<ScalarFunction>(name, Arity::Unary(), doc, default_options);
 
-  if (enable_date) {
-    auto exec = ExecTemplate<Op, days, Date32Type, OutType>::Exec;
-    DCHECK_OK(func->AddKernel({date32()}, out_type, std::move(exec), init));
-  }
-
-  if (enable_date) {
-    auto exec = ExecTemplate<Op, std::chrono::milliseconds, Date64Type, OutType>::Exec;
-    DCHECK_OK(func->AddKernel({date64()}, out_type, std::move(exec), init));
-  }
-
-  for (auto unit : internal::AllTimeUnits()) {
-    InputType in_type{match::TimestampTypeUnit(unit)};
-    switch (unit) {
-      case TimeUnit::SECOND: {
-        auto exec = ExecTemplate<Op, std::chrono::seconds, TimestampType, OutType>::Exec;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+  for (const auto in_type : in_types) {
+    switch (in_type) {
+      case WithDates: {
+        auto exec32 = ExecTemplate<Op, days, Date32Type, OutType>::Exec;
+        DCHECK_OK(func->AddKernel({date32()}, out_type, std::move(exec32), init));
+        auto exec64 =
+            ExecTemplate<Op, std::chrono::milliseconds, Date64Type, OutType>::Exec;
+        DCHECK_OK(func->AddKernel({date64()}, out_type, std::move(exec64), init));
         break;
       }
-      case TimeUnit::MILLI: {
-        auto exec =
-            ExecTemplate<Op, std::chrono::milliseconds, TimestampType, OutType>::Exec;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
-        break;
-      }
-      case TimeUnit::MICRO: {
-        auto exec =
-            ExecTemplate<Op, std::chrono::microseconds, TimestampType, OutType>::Exec;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
-        break;
-      }
-      case TimeUnit::NANO: {
-        auto exec =
-            ExecTemplate<Op, std::chrono::nanoseconds, TimestampType, OutType>::Exec;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+
+      case WithTimestamps: {
+        for (auto unit : internal::AllTimeUnits()) {
+          InputType in_type{match::TimestampTypeUnit(unit)};
+          switch (unit) {
+            case TimeUnit::SECOND: {
+              auto exec =
+                  ExecTemplate<Op, std::chrono::seconds, TimestampType, OutType>::Exec;
+              DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+              break;
+            }
+            case TimeUnit::MILLI: {
+              auto exec = ExecTemplate<Op, std::chrono::milliseconds, TimestampType,
+                                       OutType>::Exec;
+              DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+              break;
+            }
+            case TimeUnit::MICRO: {
+              auto exec = ExecTemplate<Op, std::chrono::microseconds, TimestampType,
+                                       OutType>::Exec;
+              DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+              break;
+            }
+            case TimeUnit::NANO: {
+              auto exec = ExecTemplate<Op, std::chrono::nanoseconds, TimestampType,
+                                       OutType>::Exec;
+              DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+              break;
+            }
+          }
+        }
         break;
       }
     }
   }
+
   return func;
 }
 
 template <template <typename...> class Op>
 std::shared_ptr<ScalarFunction> MakeSimpleUnaryTemporal(
-    bool enable_date, std::string name, const std::shared_ptr<arrow::DataType> out_type,
-    const FunctionDoc* doc, const FunctionOptions* default_options = NULLPTR,
-    KernelInit init = NULLPTR) {
+    std::string name, std::initializer_list<EnabledTypes> in_types,
+    const std::shared_ptr<arrow::DataType> out_type, const FunctionDoc* doc,
+    const FunctionOptions* default_options = NULLPTR, KernelInit init = NULLPTR) {
+  DCHECK_NE(in_types.size(), 0);
   auto func =
       std::make_shared<ScalarFunction>(name, Arity::Unary(), doc, default_options);
 
-  if (enable_date) {
-    auto exec = SimpleUnary<Op<days, Date32Type>>;
-    DCHECK_OK(func->AddKernel({date32()}, out_type, std::move(exec), init));
-  }
-
-  if (enable_date) {
-    auto exec = SimpleUnary<Op<std::chrono::milliseconds, Date64Type>>;
-    DCHECK_OK(func->AddKernel({date64()}, out_type, std::move(exec), init));
-  }
-
-  for (auto unit : internal::AllTimeUnits()) {
-    InputType in_type{match::TimestampTypeUnit(unit)};
-    switch (unit) {
-      case TimeUnit::SECOND: {
-        auto exec = SimpleUnary<Op<std::chrono::seconds, TimestampType>>;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
-        break;
-      }
-      case TimeUnit::MILLI: {
-        auto exec = SimpleUnary<Op<std::chrono::milliseconds, TimestampType>>;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
-        break;
-      }
-      case TimeUnit::MICRO: {
-        auto exec = SimpleUnary<Op<std::chrono::microseconds, TimestampType>>;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+  for (const auto in_type : in_types) {
+    switch (in_type) {
+      case WithDates: {
+        auto exec32 = SimpleUnary<Op<days, Date32Type>>;
+        DCHECK_OK(func->AddKernel({date32()}, out_type, std::move(exec32), init));
+        auto exec64 = SimpleUnary<Op<std::chrono::milliseconds, Date64Type>>;
+        DCHECK_OK(func->AddKernel({date64()}, out_type, std::move(exec64), init));
         break;
       }
-      case TimeUnit::NANO: {
-        auto exec = SimpleUnary<Op<std::chrono::nanoseconds, TimestampType>>;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+      case WithTimestamps: {
+        for (auto unit : internal::AllTimeUnits()) {
+          InputType in_type{match::TimestampTypeUnit(unit)};
+          switch (unit) {
+            case TimeUnit::SECOND: {
+              auto exec = SimpleUnary<Op<std::chrono::seconds, TimestampType>>;
+              DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+              break;
+            }
+            case TimeUnit::MILLI: {
+              auto exec = SimpleUnary<Op<std::chrono::milliseconds, TimestampType>>;
+              DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+              break;
+            }
+            case TimeUnit::MICRO: {
+              auto exec = SimpleUnary<Op<std::chrono::microseconds, TimestampType>>;
+              DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+              break;
+            }
+            case TimeUnit::NANO: {
+              auto exec = SimpleUnary<Op<std::chrono::nanoseconds, TimestampType>>;
+              DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+              break;
+            }
+          }
+        }
         break;
       }
     }
   }
+
   return func;
 }
 
@@ -980,81 +1096,107 @@ const FunctionDoc strftime_doc{
     {"timestamps"},
     "StrftimeOptions"};
 
+const FunctionDoc assume_timezone_doc{
+    "Convert naive timestamp to timezone-aware timestamp",
+    ("Input timestamps are assumed to be relative to the timezone given in the\n"
+     "`timezone` option. They are converted to UTC-relative timestamps and\n"
+     "the output type has its timezone set to the value of the `timezone`\n"
+     "option. Null values emit null.\n"
+     "This function is meant to be used when an external system produces\n"
+     "\"timezone-naive\" timestamps which need to be converted to\n"
+     "\"timezone-aware\" timestamps. An error is returned if the timestamps\n"
+     "already have a defined timezone."),
+    {"timestamps"},
+    "AssumeTimezoneOptions"};
+
 }  // namespace
 
 void RegisterScalarTemporal(FunctionRegistry* registry) {
+  // Date extractors
+
   auto year = MakeTemporal<Year, TemporalComponentExtract, Int64Type>(
-      /*enable_date=*/true, "year", int64(), &year_doc);
+      "year", {WithDates, WithTimestamps}, int64(), &year_doc);
   DCHECK_OK(registry->AddFunction(std::move(year)));
 
   auto month = MakeTemporal<Month, TemporalComponentExtract, Int64Type>(
-      /*enable_date=*/true, "month", int64(), &month_doc);
+      "month", {WithDates, WithTimestamps}, int64(), &month_doc);
   DCHECK_OK(registry->AddFunction(std::move(month)));
 
   auto day = MakeTemporal<Day, TemporalComponentExtract, Int64Type>(
-      /*enable_date=*/true, "day", int64(), &day_doc);
+      "day", {WithDates, WithTimestamps}, int64(), &day_doc);
   DCHECK_OK(registry->AddFunction(std::move(day)));
 
-  static auto default_day_of_week_options = DayOfWeekOptions::Defaults();
+  static const auto default_day_of_week_options = DayOfWeekOptions::Defaults();
   auto day_of_week =
       MakeTemporal<DayOfWeek, TemporalComponentExtractDayOfWeek, Int64Type>(
-          /*enable_date=*/true, "day_of_week", int64(), &day_of_week_doc,
+          "day_of_week", {WithDates, WithTimestamps}, int64(), &day_of_week_doc,
           &default_day_of_week_options, DayOfWeekState::Init);
   DCHECK_OK(registry->AddFunction(std::move(day_of_week)));
 
   auto day_of_year = MakeTemporal<DayOfYear, TemporalComponentExtract, Int64Type>(
-      /*enable_date=*/true, "day_of_year", int64(), &day_of_year_doc);
+      "day_of_year", {WithDates, WithTimestamps}, int64(), &day_of_year_doc);
   DCHECK_OK(registry->AddFunction(std::move(day_of_year)));
 
   auto iso_year = MakeTemporal<ISOYear, TemporalComponentExtract, Int64Type>(
-      /*enable_date=*/true, "iso_year", int64(), &iso_year_doc);
+      "iso_year", {WithDates, WithTimestamps}, int64(), &iso_year_doc);
   DCHECK_OK(registry->AddFunction(std::move(iso_year)));
 
   auto iso_week = MakeTemporal<ISOWeek, TemporalComponentExtract, Int64Type>(
-      /*enable_date=*/true, "iso_week", int64(), &iso_week_doc);
+      "iso_week", {WithDates, WithTimestamps}, int64(), &iso_week_doc);
   DCHECK_OK(registry->AddFunction(std::move(iso_week)));
 
   auto iso_calendar = MakeSimpleUnaryTemporal<ISOCalendar>(
-      /*enable_date=*/true, "iso_calendar", IsoCalendarType(), &iso_calendar_doc);
+      "iso_calendar", {WithDates, WithTimestamps}, IsoCalendarType(), &iso_calendar_doc);
   DCHECK_OK(registry->AddFunction(std::move(iso_calendar)));
 
   auto quarter = MakeTemporal<Quarter, TemporalComponentExtract, Int64Type>(
-      /*enable_date=*/true, "quarter", int64(), &quarter_doc);
+      "quarter", {WithDates, WithTimestamps}, int64(), &quarter_doc);
   DCHECK_OK(registry->AddFunction(std::move(quarter)));
 
+  // Date / time extractors
+
   auto hour = MakeTemporal<Hour, TemporalComponentExtract, Int64Type>(
-      /*enable_date=*/false, "hour", int64(), &hour_doc);
+      "hour", {WithTimestamps}, int64(), &hour_doc);
   DCHECK_OK(registry->AddFunction(std::move(hour)));
 
   auto minute = MakeTemporal<Minute, TemporalComponentExtract, Int64Type>(
-      /*enable_date=*/false, "minute", int64(), &minute_doc);
+      "minute", {WithTimestamps}, int64(), &minute_doc);
   DCHECK_OK(registry->AddFunction(std::move(minute)));
 
   auto second = MakeTemporal<Second, TemporalComponentExtract, Int64Type>(
-      /*enable_date=*/false, "second", int64(), &second_doc);
+      "second", {WithTimestamps}, int64(), &second_doc);
   DCHECK_OK(registry->AddFunction(std::move(second)));
 
   auto millisecond = MakeTemporal<Millisecond, TemporalComponentExtract, Int64Type>(
-      /*enable_date=*/false, "millisecond", int64(), &millisecond_doc);
+      "millisecond", {WithTimestamps}, int64(), &millisecond_doc);
   DCHECK_OK(registry->AddFunction(std::move(millisecond)));
 
   auto microsecond = MakeTemporal<Microsecond, TemporalComponentExtract, Int64Type>(
-      /*enable_date=*/false, "microsecond", int64(), &microsecond_doc);
+      "microsecond", {WithTimestamps}, int64(), &microsecond_doc);
   DCHECK_OK(registry->AddFunction(std::move(microsecond)));
 
   auto nanosecond = MakeTemporal<Nanosecond, TemporalComponentExtract, Int64Type>(
-      /*enable_date=*/false, "nanosecond", int64(), &nanosecond_doc);
+      "nanosecond", {WithTimestamps}, int64(), &nanosecond_doc);
   DCHECK_OK(registry->AddFunction(std::move(nanosecond)));
 
   auto subsecond = MakeTemporal<Subsecond, TemporalComponentExtract, DoubleType>(
-      /*enable_date=*/false, "subsecond", float64(), &subsecond_doc);
+      "subsecond", {WithTimestamps}, float64(), &subsecond_doc);
   DCHECK_OK(registry->AddFunction(std::move(subsecond)));
 
-  static auto default_strftime_options = StrftimeOptions();
+  // Timezone-related functions
+
+  static const auto default_strftime_options = StrftimeOptions();
   auto strftime = MakeSimpleUnaryTemporal<Strftime>(
-      /*enable_date=*/false, "strftime", utf8(), &strftime_doc, &default_strftime_options,
+      "strftime", {WithTimestamps}, utf8(), &strftime_doc, &default_strftime_options,
       StrftimeState::Init);
   DCHECK_OK(registry->AddFunction(std::move(strftime)));
+
+  auto assume_timezone =
+      MakeTemporal<AssumeTimezone, AssumeTimezoneExtractor, TimestampType>(
+          "assume_timezone", {WithTimestamps},
+          OutputType::Resolver(ResolveAssumeTimezoneOutput), &assume_timezone_doc,
+          nullptr, AssumeTimezoneState::Init);
+  DCHECK_OK(registry->AddFunction(std::move(assume_timezone)));
 }
 
 }  // namespace internal
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
index e3e8777fd2f56..c238f95d6f440 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
@@ -16,6 +16,7 @@
 // under the License.
 
 #include <gtest/gtest.h>
+
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/kernels/common.h"
 #include "arrow/compute/kernels/test_util.h"
@@ -430,7 +431,111 @@ TEST_F(ScalarTemporalTest, DayOfWeek) {
                                                        /*week_start=*/8)));
 }
 
+// TODO: We should test on windows once ARROW-13168 is resolved.
 #ifndef _WIN32
+TEST_F(ScalarTemporalTest, TestAssumeTimezone) {
+  std::string timezone_utc = "UTC";
+  std::string timezone_kolkata = "Asia/Kolkata";
+  std::string timezone_us_central = "US/Central";
+  const char* times_utc = R"(["1970-01-01T00:00:00", null])";
+  const char* times_kolkata = R"(["1970-01-01T05:30:00", null])";
+  const char* times_us_central = R"(["1969-12-31T18:00:00", null])";
+  auto options_utc = AssumeTimezoneOptions(timezone_utc);
+  auto options_kolkata = AssumeTimezoneOptions(timezone_kolkata);
+  auto options_us_central = AssumeTimezoneOptions(timezone_us_central);
+  auto options_invalid = AssumeTimezoneOptions("Europe/Brusselsss");
+
+  for (auto u : internal::AllTimeUnits()) {
+    auto unit = timestamp(u);
+    auto unit_utc = timestamp(u, timezone_utc);
+    auto unit_kolkata = timestamp(u, timezone_kolkata);
+    auto unit_us_central = timestamp(u, timezone_us_central);
+
+    CheckScalarUnary("assume_timezone", unit, times_utc, unit_utc, times_utc,
+                     &options_utc);
+    CheckScalarUnary("assume_timezone", unit, times_kolkata, unit_kolkata, times_utc,
+                     &options_kolkata);
+    CheckScalarUnary("assume_timezone", unit, times_us_central, unit_us_central,
+                     times_utc, &options_us_central);
+    ASSERT_RAISES(Invalid,
+                  AssumeTimezone(ArrayFromJSON(unit_kolkata, times_utc), options_utc));
+    ASSERT_RAISES(Invalid,
+                  AssumeTimezone(ArrayFromJSON(unit, times_utc), options_invalid));
+  }
+}
+
+TEST_F(ScalarTemporalTest, TestAssumeTimezoneAmbiguous) {
+  std::string timezone = "CET";
+  const char* times = R"(["2018-10-28 01:20:00",
+                          "2018-10-28 02:36:00",
+                          "2018-10-28 03:46:00"])";
+  const char* times_earliest = R"(["2018-10-27 23:20:00",
+                                   "2018-10-28 00:36:00",
+                                   "2018-10-28 02:46:00"])";
+  const char* times_latest = R"(["2018-10-27 23:20:00",
+                                 "2018-10-28 01:36:00",
+                                 "2018-10-28 02:46:00"])";
+
+  auto options_earliest =
+      AssumeTimezoneOptions(timezone, AssumeTimezoneOptions::AMBIGUOUS_EARLIEST);
+  auto options_latest =
+      AssumeTimezoneOptions(timezone, AssumeTimezoneOptions::AMBIGUOUS_LATEST);
+  auto options_raise =
+      AssumeTimezoneOptions(timezone, AssumeTimezoneOptions::AMBIGUOUS_RAISE);
+
+  for (auto u : internal::AllTimeUnits()) {
+    auto unit = timestamp(u);
+    auto unit_local = timestamp(u, timezone);
+    ASSERT_RAISES(Invalid, AssumeTimezone(ArrayFromJSON(unit, times), options_raise));
+    CheckScalarUnary("assume_timezone", unit, times, unit_local, times_earliest,
+                     &options_earliest);
+    CheckScalarUnary("assume_timezone", unit, times, unit_local, times_latest,
+                     &options_latest);
+  }
+}
+
+TEST_F(ScalarTemporalTest, TestAssumeTimezoneNonexistent) {
+  std::string timezone = "Europe/Warsaw";
+  const char* times = R"(["2015-03-29 02:30:00", "2015-03-29 03:30:00"])";
+  const char* times_latest = R"(["2015-03-29 01:00:00", "2015-03-29 01:30:00"])";
+  const char* times_earliest = R"(["2015-03-29 00:59:59", "2015-03-29 01:30:00"])";
+  const char* times_earliest_milli =
+      R"(["2015-03-29 00:59:59.999", "2015-03-29 01:30:00"])";
+  const char* times_earliest_micro =
+      R"(["2015-03-29 00:59:59.999999", "2015-03-29 01:30:00"])";
+  const char* times_earliest_nano =
+      R"(["2015-03-29 00:59:59.999999999", "2015-03-29 01:30:00"])";
+
+  auto options_raise =
+      AssumeTimezoneOptions(timezone, AssumeTimezoneOptions::AMBIGUOUS_RAISE,
+                            AssumeTimezoneOptions::NONEXISTENT_RAISE);
+  auto options_latest =
+      AssumeTimezoneOptions(timezone, AssumeTimezoneOptions::AMBIGUOUS_RAISE,
+                            AssumeTimezoneOptions::NONEXISTENT_LATEST);
+  auto options_earliest =
+      AssumeTimezoneOptions(timezone, AssumeTimezoneOptions::AMBIGUOUS_RAISE,
+                            AssumeTimezoneOptions::NONEXISTENT_EARLIEST);
+
+  for (auto u : internal::AllTimeUnits()) {
+    auto unit = timestamp(u);
+    auto unit_local = timestamp(u, timezone);
+    ASSERT_RAISES(Invalid, AssumeTimezone(ArrayFromJSON(unit, times), options_raise));
+    CheckScalarUnary("assume_timezone", unit, times, unit_local, times_latest,
+                     &options_latest);
+  }
+  CheckScalarUnary("assume_timezone", timestamp(TimeUnit::SECOND), times,
+                   timestamp(TimeUnit::SECOND, timezone), times_earliest,
+                   &options_earliest);
+  CheckScalarUnary("assume_timezone", timestamp(TimeUnit::MILLI), times,
+                   timestamp(TimeUnit::MILLI, timezone), times_earliest_milli,
+                   &options_earliest);
+  CheckScalarUnary("assume_timezone", timestamp(TimeUnit::MICRO), times,
+                   timestamp(TimeUnit::MICRO, timezone), times_earliest_micro,
+                   &options_earliest);
+  CheckScalarUnary("assume_timezone", timestamp(TimeUnit::NANO), times,
+                   timestamp(TimeUnit::NANO, timezone), times_earliest_nano,
+                   &options_earliest);
+}
 
 TEST_F(ScalarTemporalTest, Strftime) {
   auto options_default = StrftimeOptions();
@@ -542,8 +647,7 @@ TEST_F(ScalarTemporalTest, StrftimeInvalidLocale) {
                                   testing::HasSubstr("Cannot find locale 'non-existent'"),
                                   Strftime(arr, options));
 }
-
-#endif
+#endif  // !_WIN32
 
 }  // namespace compute
 }  // namespace arrow
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 39697ea425c1e..953ad22da05b7 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1263,6 +1263,30 @@ For timestamps inputs with non-empty timezone, localized timestamp components wi
 
 .. _ISO 8601 week date definition: https://en.wikipedia.org/wiki/ISO_week_date#First_week
 
+Timezone handling
+~~~~~~~~~~~~~~~~~
+
+This function is meant to be used when an external system produces
+"timezone-naive" timestamps which need to be converted to "timezone-aware"
+timestamps (see for example the `definition
+<https://docs.python.org/3/library/datetime.html#aware-and-naive-objects>`__
+in the Python documentation).
+
+Input timestamps are assumed to be relative to the timezone given in
+:member:`AssumeTimezoneOptions::timezone`. They are converted to
+UTC-relative timestamps with the timezone metadata set to the above value.
+An error is returned if the timestamps already have the timezone metadata set.
+
++--------------------+------------+-------------------+---------------+----------------------------------+-------+
+| Function name      | Arity      | Input types       | Output type   | Options class                    | Notes |
++====================+============+===================+===============+==================================+=======+
+| assume_timezone    | Unary      | Timestamp         | Timestamp     | :struct:`AssumeTimezoneOptions`  | \(1)  |
++--------------------+------------+-------------------+---------------+----------------------------------+-------+
+
+* \(1) In addition to the timezone value, :struct:`AssumeTimezoneOptions`
+  allows choosing the behaviour when a timestamp is ambiguous or nonexistent
+  in the given timezone (because of DST shifts).
+
 
 Array-wise ("vector") functions
 -------------------------------
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index aaf4c9f29162f..e0eb41f4eaa7f 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -1005,6 +1005,41 @@ class DayOfWeekOptions(_DayOfWeekOptions):
         self._set_options(one_based_numbering, week_start)
 
 
+cdef class _AssumeTimezoneOptions(FunctionOptions):
+    def _set_options(self, timezone, ambiguous, nonexistent):
+        ambiguous_dict = {
+            'raise': CAssumeTimezoneAmbiguous_AMBIGUOUS_RAISE,
+            'earliest': CAssumeTimezoneAmbiguous_AMBIGUOUS_EARLIEST,
+            'latest': CAssumeTimezoneAmbiguous_AMBIGUOUS_LATEST,
+        }
+        nonexistent_dict = {
+            'raise': CAssumeTimezoneNonexistent_NONEXISTENT_RAISE,
+            'earliest': CAssumeTimezoneNonexistent_NONEXISTENT_EARLIEST,
+            'latest': CAssumeTimezoneNonexistent_NONEXISTENT_LATEST,
+        }
+
+        if ambiguous not in ambiguous_dict:
+            raise ValueError(
+                "{!r} is not a valid 'ambiguous' keyword".format(ambiguous)
+            )
+        if nonexistent not in nonexistent_dict:
+            raise ValueError(
+                "{!r} is not a valid 'nonexistent' keyword".format(
+                    nonexistent)
+            )
+        self.wrapped.reset(
+            new CAssumeTimezoneOptions(
+                tobytes(timezone),
+                ambiguous_dict[ambiguous],
+                nonexistent_dict[nonexistent])
+        )
+
+
+class AssumeTimezoneOptions(_AssumeTimezoneOptions):
+    def __init__(self, timezone, *, ambiguous="raise", nonexistent="raise"):
+        self._set_options(timezone, ambiguous, nonexistent)
+
+
 cdef class _NullOptions(FunctionOptions):
     def _set_options(self, nan_is_null):
         self.wrapped.reset(
diff --git a/python/pyarrow/compute.py b/python/pyarrow/compute.py
index 4bc4034f64c7d..5ee9bb0a434e1 100644
--- a/python/pyarrow/compute.py
+++ b/python/pyarrow/compute.py
@@ -30,6 +30,7 @@
     VectorKernel,
     # Option classes
     ArraySortOptions,
+    AssumeTimezoneOptions,
     CastOptions,
     CountOptions,
     DayOfWeekOptions,
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index dc41e577d94d7..b1e963c24e592 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -1964,6 +1964,30 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
         c_bool one_based_numbering
         uint32_t week_start
 
+    enum CAssumeTimezoneAmbiguous \
+            "arrow::compute::AssumeTimezoneOptions::Ambiguous":
+        CAssumeTimezoneAmbiguous_AMBIGUOUS_RAISE \
+            "arrow::compute::AssumeTimezoneOptions::AMBIGUOUS_RAISE"
+        CAssumeTimezoneAmbiguous_AMBIGUOUS_EARLIEST \
+            "arrow::compute::AssumeTimezoneOptions::AMBIGUOUS_EARLIEST"
+        CAssumeTimezoneAmbiguous_AMBIGUOUS_LATEST \
+            "arrow::compute::AssumeTimezoneOptions::AMBIGUOUS_LATEST"
+
+    enum CAssumeTimezoneNonexistent \
+            "arrow::compute::AssumeTimezoneOptions::Nonexistent":
+        CAssumeTimezoneNonexistent_NONEXISTENT_RAISE \
+            "arrow::compute::AssumeTimezoneOptions::NONEXISTENT_RAISE"
+        CAssumeTimezoneNonexistent_NONEXISTENT_EARLIEST \
+            "arrow::compute::AssumeTimezoneOptions::NONEXISTENT_EARLIEST"
+        CAssumeTimezoneNonexistent_NONEXISTENT_LATEST \
+            "arrow::compute::AssumeTimezoneOptions::NONEXISTENT_LATEST"
+
+    cdef cppclass CAssumeTimezoneOptions \
+            "arrow::compute::AssumeTimezoneOptions"(CFunctionOptions):
+        CAssumeTimezoneOptions(
+            c_string timezone, CAssumeTimezoneAmbiguous ambiguous,
+            CAssumeTimezoneNonexistent nonexistent)
+
     cdef cppclass CNullOptions \
             "arrow::compute::NullOptions"(CFunctionOptions):
         CNullOptions(c_bool nan_is_null)
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 334a2a7bda327..2349f84b55e40 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -34,7 +34,6 @@
 import pyarrow as pa
 import pyarrow.compute as pc
 
-
 all_array_types = [
     ('bool', [True, False, False, True, True]),
     ('uint8', np.arange(5)),
@@ -53,22 +52,19 @@
     (pa.list_(pa.int8()), [[1, 2], [3, 4], [5, 6], None, [9, 16]]),
     (pa.large_list(pa.int16()), [[1], [2, 3, 4], [5, 6], None, [9, 16]]),
     (pa.struct([('a', pa.int8()), ('b', pa.int8())]), [
-     {'a': 1, 'b': 2}, None, {'a': 3, 'b': 4}, None, {'a': 5, 'b': 6}]),
+        {'a': 1, 'b': 2}, None, {'a': 3, 'b': 4}, None, {'a': 5, 'b': 6}]),
 ]
 
-
 exported_functions = [
     func for (name, func) in sorted(pc.__dict__.items())
     if hasattr(func, '__arrow_compute_function__')]
 
-
 exported_option_classes = [
     cls for (name, cls) in sorted(pc.__dict__.items())
     if (isinstance(cls, type) and
         cls is not pc.FunctionOptions and
         issubclass(cls, pc.FunctionOptions))]
 
-
 numerical_arrow_types = [
     pa.int8(),
     pa.int16(),
@@ -131,9 +127,16 @@ def test_option_class_equality():
         pc.TrimOptions(" "),
         pc.StrftimeOptions(),
     ]
+    # TODO: We should test on windows once ARROW-13168 is resolved.
+    # Timezone database is not available on Windows yet
+    if sys.platform != 'win32':
+        options.append(pc.AssumeTimezoneOptions("Europe/Ljubljana"))
+
     classes = {type(option) for option in options}
     for cls in exported_option_classes:
-        if cls not in classes:
+        # Timezone database is not available on Windows yet
+        if cls not in classes and sys.platform != 'win32' and \
+                cls != pc.AssumeTimezoneOptions:
             try:
                 options.append(cls())
             except TypeError:
@@ -775,7 +778,7 @@ def find_new_unicode_codepoints():
 def test_string_py_compat_boolean(function_name, variant):
     arrow_name = variant + "_" + function_name
     py_name = function_name.replace('_', '')
-    ignore = codepoints_ignore.get(function_name, set()) |\
+    ignore = codepoints_ignore.get(function_name, set()) | \
         find_new_unicode_codepoints()
     for i in range(128 if ascii else 0x11000):
         if i in range(0xD800, 0xE000):
@@ -1181,9 +1184,11 @@ def test_filter_null_type():
 @pytest.mark.parametrize("typ", ["array", "chunked_array"])
 def test_compare_array(typ):
     if typ == "array":
-        def con(values): return pa.array(values)
+        def con(values):
+            return pa.array(values)
     else:
-        def con(values): return pa.chunked_array([values])
+        def con(values):
+            return pa.chunked_array([values])
 
     arr1 = con([1, 2, 3, 4, None])
     arr2 = con([1, 1, 4, None, 4])
@@ -1210,9 +1215,11 @@ def con(values): return pa.chunked_array([values])
 @pytest.mark.parametrize("typ", ["array", "chunked_array"])
 def test_compare_string_scalar(typ):
     if typ == "array":
-        def con(values): return pa.array(values)
+        def con(values):
+            return pa.array(values)
     else:
-        def con(values): return pa.chunked_array([values])
+        def con(values):
+            return pa.chunked_array([values])
 
     arr = con(['a', 'b', 'c', None])
     scalar = pa.scalar('b')
@@ -1245,9 +1252,11 @@ def con(values): return pa.chunked_array([values])
 @pytest.mark.parametrize("typ", ["array", "chunked_array"])
 def test_compare_scalar(typ):
     if typ == "array":
-        def con(values): return pa.array(values)
+        def con(values):
+            return pa.array(values)
     else:
-        def con(values): return pa.chunked_array([values])
+        def con(values):
+            return pa.chunked_array([values])
 
     arr = con([1, 2, 3, None])
     scalar = pa.scalar(2)
@@ -1440,7 +1449,7 @@ def test_logical():
 
 
 def test_cast():
-    arr = pa.array([2**63 - 1], type='int64')
+    arr = pa.array([2 ** 63 - 1], type='int64')
 
     with pytest.raises(pa.ArrowInvalid):
         pc.cast(arr, 'int32')
@@ -1556,8 +1565,8 @@ def _check_datetime_components(timestamps, timezone=None):
         "UTC").tz_convert(timezone).to_series()
     tsa = pa.array(ts, pa.timestamp("ns", tz=timezone))
 
-    subseconds = ((ts.dt.microsecond * 10**3 +
-                   ts.dt.nanosecond) * 10**-9).round(9)
+    subseconds = ((ts.dt.microsecond * 10 ** 3 +
+                   ts.dt.nanosecond) * 10 ** -9).round(9)
     iso_calendar_fields = [
         pa.field('iso_year', pa.int64()),
         pa.field('iso_week', pa.int64()),
@@ -1592,8 +1601,8 @@ def _check_datetime_components(timestamps, timezone=None):
     assert pc.hour(tsa).equals(pa.array(ts.dt.hour))
     assert pc.minute(tsa).equals(pa.array(ts.dt.minute))
     assert pc.second(tsa).equals(pa.array(ts.dt.second.values))
-    assert pc.millisecond(tsa).equals(pa.array(ts.dt.microsecond // 10**3))
-    assert pc.microsecond(tsa).equals(pa.array(ts.dt.microsecond % 10**3))
+    assert pc.millisecond(tsa).equals(pa.array(ts.dt.microsecond // 10 ** 3))
+    assert pc.microsecond(tsa).equals(pa.array(ts.dt.microsecond % 10 ** 3))
     assert pc.nanosecond(tsa).equals(pa.array(ts.dt.nanosecond))
     assert pc.subsecond(tsa).equals(pa.array(subseconds))
 
@@ -1639,6 +1648,103 @@ def test_extract_datetime_components():
             _check_datetime_components(timestamps, timezone)
 
 
+# TODO: We should test on windows once ARROW-13168 is resolved.
+@pytest.mark.pandas
+@pytest.mark.skipif(sys.platform == 'win32',
+                    reason="Timezone database is not available on Windows yet")
+def test_assume_timezone():
+    from pyarrow.vendored.version import Version
+
+    ts_type = pa.timestamp("ns")
+    timestamps = pd.to_datetime(["1970-01-01T00:00:59.123456789",
+                                 "2000-02-29T23:23:23.999999999",
+                                 "2033-05-18T03:33:20.000000000",
+                                 "2020-01-01T01:05:05.001",
+                                 "2019-12-31T02:10:10.002",
+                                 "2019-12-30T03:15:15.003",
+                                 "2009-12-31T04:20:20.004132",
+                                 "2010-01-01T05:25:25.005321",
+                                 "2010-01-03T06:30:30.006163",
+                                 "2010-01-04T07:35:35",
+                                 "2006-01-01T08:40:40",
+                                 "2005-12-31T09:45:45",
+                                 "2008-12-28",
+                                 "2008-12-29",
+                                 "2012-01-01 01:02:03"])
+    nonexistent = pd.to_datetime(["2015-03-29 02:30:00",
+                                  "2015-03-29 03:30:00"])
+    ambiguous = pd.to_datetime(["2018-10-28 01:20:00",
+                                "2018-10-28 02:36:00",
+                                "2018-10-28 03:46:00"])
+    ambiguous_array = pa.array(ambiguous, type=ts_type)
+    nonexistent_array = pa.array(nonexistent, type=ts_type)
+
+    for timezone in ["UTC", "US/Central", "Asia/Kolkata"]:
+        options = pc.AssumeTimezoneOptions(timezone)
+        ta = pa.array(timestamps, type=ts_type)
+        expected = timestamps.tz_localize(timezone)
+        result = pc.assume_timezone(ta, options=options)
+        assert result.equals(pa.array(expected))
+
+        ta_zoned = pa.array(timestamps, type=pa.timestamp("ns", timezone))
+        with pytest.raises(pa.ArrowInvalid,
+                           match="already have a timezone:"):
+            pc.assume_timezone(ta_zoned, options=options)
+
+    invalid_options = pc.AssumeTimezoneOptions("Europe/Brusselsss")
+    with pytest.raises(ValueError, match="not found in timezone database"):
+        pc.assume_timezone(ta, options=invalid_options)
+
+    timezone = "Europe/Brussels"
+
+    # nonexistent parameter was introduced in Pandas 0.24.0
+    if Version(pd.__version__) >= Version("0.24.0"):
+        options_nonexistent_raise = pc.AssumeTimezoneOptions(timezone)
+        options_nonexistent_earliest = pc.AssumeTimezoneOptions(
+            timezone, ambiguous="raise", nonexistent="earliest")
+        options_nonexistent_latest = pc.AssumeTimezoneOptions(
+            timezone, ambiguous="raise", nonexistent="latest")
+
+        with pytest.raises(
+                ValueError,
+                match=f"Timestamp doesn't exist in timezone '{timezone}'"):
+            pc.assume_timezone(nonexistent_array,
+                               options=options_nonexistent_raise)
+
+        expected = pa.array(nonexistent.tz_localize(
+            timezone, nonexistent="shift_forward"))
+        result = pc.assume_timezone(
+            nonexistent_array, options=options_nonexistent_latest)
+        expected.equals(result)
+
+        expected = pa.array(nonexistent.tz_localize(
+            timezone, nonexistent="shift_backward"))
+        result = pc.assume_timezone(
+            nonexistent_array, options=options_nonexistent_earliest)
+        expected.equals(result)
+
+    options_ambiguous_raise = pc.AssumeTimezoneOptions(timezone)
+    options_ambiguous_latest = pc.AssumeTimezoneOptions(
+        timezone, ambiguous="latest", nonexistent="raise")
+    options_ambiguous_earliest = pc.AssumeTimezoneOptions(
+        timezone, ambiguous="earliest", nonexistent="raise")
+
+    with pytest.raises(
+            ValueError,
+            match=f"Timestamp is ambiguous in timezone '{timezone}'"):
+        pc.assume_timezone(ambiguous_array, options=options_ambiguous_raise)
+
+    expected = ambiguous.tz_localize(timezone, ambiguous=[True, True, True])
+    result = pc.assume_timezone(
+        ambiguous_array, options=options_ambiguous_earliest)
+    result.equals(pa.array(expected))
+
+    expected = ambiguous.tz_localize(timezone, ambiguous=[False, False, False])
+    result = pc.assume_timezone(
+        ambiguous_array, options=options_ambiguous_latest)
+    result.equals(pa.array(expected))
+
+
 def test_count():
     arr = pa.array([1, 2, 3, None, None])
     assert pc.count(arr).as_py() == 3
diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index 0f08b41e85da8..c22038b2faaea 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -325,6 +325,22 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
         cpp11::as_cpp<arrow::TimeUnit::type>(options["unit"]));
   }
 
+  if (func_name == "assume_timezone") {
+    using Options = arrow::compute::AssumeTimezoneOptions;
+    enum Options::Ambiguous ambiguous;
+    enum Options::Nonexistent nonexistent;
+
+    if (!Rf_isNull(options["ambiguous"])) {
+      ambiguous = cpp11::as_cpp<enum Options::Ambiguous>(options["ambiguous"]);
+    }
+    if (!Rf_isNull(options["nonexistent"])) {
+      nonexistent = cpp11::as_cpp<enum Options::Nonexistent>(options["nonexistent"]);
+    }
+
+    return std::make_shared<Options>(cpp11::as_cpp<std::string>(options["timezone"]),
+                                     ambiguous, nonexistent);
+  }
+
   if (func_name == "split_pattern" || func_name == "split_pattern_regex") {
     using Options = arrow::compute::SplitPatternOptions;
     int64_t max_splits = -1;