diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index f0257772d4a..b6cabddd118 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -35,7 +35,12 @@ namespace {
 using arrow_vendored::date::days;
 using arrow_vendored::date::floor;
 using arrow_vendored::date::hh_mm_ss;
+using arrow_vendored::date::local_days;
+using arrow_vendored::date::local_time;
+using arrow_vendored::date::locate_zone;
+using arrow_vendored::date::sys_days;
 using arrow_vendored::date::sys_time;
+using arrow_vendored::date::time_zone;
 using arrow_vendored::date::trunc;
 using arrow_vendored::date::weekday;
 using arrow_vendored::date::weeks;
@@ -51,6 +56,12 @@ using internal::applicator::SimpleUnary;
 
 using DayOfWeekState = OptionsWrapper<DayOfWeekOptions>;
 
+const std::shared_ptr<DataType>& IsoCalendarType() {
+  static auto type = struct_({field("iso_year", int64()), field("iso_week", int64()),
+                              field("iso_day_of_week", int64())});
+  return type;
+}
+
 const std::string& GetInputTimezone(const Datum& datum) {
   return checked_cast<const TimestampType&>(*datum.type()).timezone();
 }
@@ -63,29 +74,79 @@ const std::string& GetInputTimezone(const ArrayData& array) {
   return checked_cast<const TimestampType&>(*array.type).timezone();
 }
 
-template <typename T>
-Status TemporalComponentExtractCheckTimezone(const T& input) {
-  const auto& timezone = GetInputTimezone(input);
-  if (!timezone.empty()) {
-    return Status::NotImplemented(
-        "Cannot extract components from timestamp with specific timezone: ", timezone);
+struct NonZonedLocalizer {
+  // No-op conversions: UTC -> UTC
+  template <typename Duration>
+  sys_time<Duration> ConvertTimePoint(int64_t t) const {
+    return sys_time<Duration>(Duration{t});
+  }
+
+  sys_days ConvertDays(sys_days d) const { return d; }
+};
+
+struct ZonedLocalizer {
+  // Timezone-localizing conversions: UTC -> local time
+  const time_zone* tz;
+
+  template <typename Duration>
+  local_time<Duration> ConvertTimePoint(int64_t t) const {
+    return tz->to_local(sys_time<Duration>(Duration{t}));
   }
-  return Status::OK();
-}
 
-template <typename Op, typename OutType>
-struct TemporalComponentExtract {
-  using OutValue = typename internal::GetOutputType<OutType>::T;
+  local_days ConvertDays(sys_days d) const { return local_days(year_month_day(d)); }
+};
+
+//
+// Executor class for temporal component extractors, i.e. scalar kernels
+// with the signature Timestamp -> <non-temporal scalar type `OutType`>
+//
+// The `Op` parameter is templated on the Duration (which depends on the timestamp
+// unit) and a Localizer class (depending on whether the timestamp has a
+// timezone defined).
+//
+template <template <typename...> class Op, typename Duration, typename OutType>
+struct TemporalComponentExtractBase {
+  template <typename OptionsType>
+  static Status ExecWithOptions(KernelContext* ctx, const OptionsType* options,
+                                const ExecBatch& batch, Datum* out) {
+    const auto& timezone = GetInputTimezone(batch.values[0]);
+    if (timezone.empty()) {
+      using ExecTemplate = Op<Duration, NonZonedLocalizer>;
+      auto op = ExecTemplate(options, NonZonedLocalizer());
+      applicator::ScalarUnaryNotNullStateful<OutType, TimestampType, ExecTemplate> kernel{
+          op};
+      return kernel.Exec(ctx, batch, out);
+    } else {
+      const time_zone* tz;
+      try {
+        tz = locate_zone(timezone);
+      } catch (const std::runtime_error& ex) {
+        return Status::Invalid(ex.what());
+      }
+      using ExecTemplate = Op<Duration, ZonedLocalizer>;
+      auto op = ExecTemplate(options, ZonedLocalizer{tz});
+      applicator::ScalarUnaryNotNullStateful<OutType, TimestampType, ExecTemplate> kernel{
+          op};
+      return kernel.Exec(ctx, batch, out);
+    }
+  }
+};
+
+template <template <typename...> class Op, typename Duration, typename OutType>
+struct TemporalComponentExtract
+    : public TemporalComponentExtractBase<Op, Duration, OutType> {
+  using Base = TemporalComponentExtractBase<Op, Duration, OutType>;
 
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-    RETURN_NOT_OK(TemporalComponentExtractCheckTimezone(batch.values[0]));
-    return ScalarUnaryNotNull<OutType, TimestampType, Op>::Exec(ctx, batch, out);
+    const FunctionOptions* options = nullptr;
+    return Base::ExecWithOptions(ctx, options, batch, out);
   }
 };
 
-template <typename Op, typename OutType>
-struct DayOfWeekExec {
-  using OutValue = typename internal::GetOutputType<OutType>::T;
+template <template <typename...> class Op, typename Duration, typename OutType>
+struct TemporalComponentExtractDayOfWeek
+    : public TemporalComponentExtractBase<Op, Duration, OutType> {
+  using Base = TemporalComponentExtractBase<Op, Duration, OutType>;
 
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
     const DayOfWeekOptions& options = DayOfWeekState::Get(ctx);
@@ -94,48 +155,65 @@ struct DayOfWeekExec {
           "week_start must follow ISO convention (Monday=1, Sunday=7). Got week_start=",
           options.week_start);
     }
-
-    RETURN_NOT_OK(TemporalComponentExtractCheckTimezone(batch.values[0]));
-    applicator::ScalarUnaryNotNullStateful<OutType, TimestampType, Op> kernel{
-        Op(options)};
-    return kernel.Exec(ctx, batch, out);
+    return Base::ExecWithOptions(ctx, &options, batch, out);
   }
 };
 
 // ----------------------------------------------------------------------
 // Extract year from timestamp
+//
+// This class and the following (`Month`, etc.) are to be used as the `Op`
+// parameter to `TemporalComponentExtract`.
 
-template <typename Duration>
+template <typename Duration, typename Localizer>
 struct Year {
+  Year(const FunctionOptions* options, Localizer&& localizer)
+      : localizer_(std::move(localizer)) {}
+
   template <typename T, typename Arg0>
-  static T Call(KernelContext*, Arg0 arg, Status*) {
+  T Call(KernelContext*, Arg0 arg, Status*) const {
     return static_cast<T>(static_cast<const int32_t>(
-        year_month_day(floor<days>(sys_time<Duration>(Duration{arg}))).year()));
+        year_month_day(floor<days>(localizer_.template ConvertTimePoint<Duration>(arg)))
+            .year()));
   }
+
+  Localizer localizer_;
 };
 
 // ----------------------------------------------------------------------
 // Extract month from timestamp
 
-template <typename Duration>
+template <typename Duration, typename Localizer>
 struct Month {
+  explicit Month(const FunctionOptions* options, Localizer&& localizer)
+      : localizer_(std::move(localizer)) {}
+
   template <typename T, typename Arg0>
-  static T Call(KernelContext*, Arg0 arg, Status*) {
+  T Call(KernelContext*, Arg0 arg, Status*) const {
     return static_cast<T>(static_cast<const uint32_t>(
-        year_month_day(floor<days>(sys_time<Duration>(Duration{arg}))).month()));
+        year_month_day(floor<days>(localizer_.template ConvertTimePoint<Duration>(arg)))
+            .month()));
   }
+
+  Localizer localizer_;
 };
 
 // ----------------------------------------------------------------------
 // Extract day from timestamp
 
-template <typename Duration>
+template <typename Duration, typename Localizer>
 struct Day {
+  explicit Day(const FunctionOptions* options, Localizer&& localizer)
+      : localizer_(std::move(localizer)) {}
+
   template <typename T, typename Arg0>
-  static T Call(KernelContext*, Arg0 arg, Status*) {
+  T Call(KernelContext*, Arg0 arg, Status*) const {
     return static_cast<T>(static_cast<const uint32_t>(
-        year_month_day(floor<days>(sys_time<Duration>(Duration{arg}))).day()));
+        year_month_day(floor<days>(localizer_.template ConvertTimePoint<Duration>(arg)))
+            .day()));
   }
+
+  Localizer localizer_;
 };
 
 // ----------------------------------------------------------------------
@@ -145,38 +223,46 @@ struct Day {
 // by 6. Start day of the week (Monday=1, Sunday=7) and numbering start (0 or 1) can be
 // set using DayOfWeekOptions
 
-template <typename Duration>
+template <typename Duration, typename Localizer>
 struct DayOfWeek {
-  explicit DayOfWeek(const DayOfWeekOptions& options) {
+  explicit DayOfWeek(const DayOfWeekOptions* options, Localizer&& localizer)
+      : localizer_(std::move(localizer)) {
     for (int i = 0; i < 7; i++) {
-      lookup_table[i] = i + 8 - options.week_start;
+      lookup_table[i] = i + 8 - options->week_start;
       lookup_table[i] = (lookup_table[i] > 6) ? lookup_table[i] - 7 : lookup_table[i];
-      lookup_table[i] += options.one_based_numbering;
+      lookup_table[i] += options->one_based_numbering;
     }
   }
 
   template <typename T, typename Arg0>
   T Call(KernelContext*, Arg0 arg, Status*) const {
     const auto wd = arrow_vendored::date::year_month_weekday(
-                        floor<days>(sys_time<Duration>(Duration{arg})))
+                        floor<days>(localizer_.template ConvertTimePoint<Duration>(arg)))
                         .weekday()
                         .iso_encoding();
     return lookup_table[wd - 1];
   }
+
   std::array<int64_t, 7> lookup_table;
+  Localizer localizer_;
 };
 
 // ----------------------------------------------------------------------
 // Extract day of year from timestamp
 
-template <typename Duration>
+template <typename Duration, typename Localizer>
 struct DayOfYear {
+  explicit DayOfYear(const FunctionOptions* options, Localizer&& localizer)
+      : localizer_(std::move(localizer)) {}
+
   template <typename T, typename Arg0>
-  static T Call(KernelContext*, Arg0 arg, Status*) {
-    const auto t = floor<days>(sys_time<Duration>(Duration{arg}));
+  T Call(KernelContext*, Arg0 arg, Status*) const {
+    const auto t = floor<days>(localizer_.template ConvertTimePoint<Duration>(arg));
     return static_cast<T>(
-        (t - sys_time<days>(year_month_day(t).year() / jan / 0)).count());
+        (t - localizer_.ConvertDays(year_month_day(t).year() / jan / 0)).count());
   }
+
+  Localizer localizer_;
 };
 
 // ----------------------------------------------------------------------
@@ -185,18 +271,23 @@ struct DayOfYear {
 // First week of an ISO year has the majority (4 or more) of it's days in January.
 // Last week of an ISO year has the year's last Thursday in it.
 
-template <typename Duration>
+template <typename Duration, typename Localizer>
 struct ISOYear {
+  explicit ISOYear(const FunctionOptions* options, Localizer&& localizer)
+      : localizer_(std::move(localizer)) {}
+
   template <typename T, typename Arg0>
-  static T Call(KernelContext*, Arg0 arg, Status*) {
-    const auto t = floor<days>(sys_time<Duration>(Duration{arg}));
+  T Call(KernelContext*, Arg0 arg, Status*) const {
+    const auto t = floor<days>(localizer_.template ConvertTimePoint<Duration>(arg));
     auto y = year_month_day{t + days{3}}.year();
-    auto start = sys_time<days>((y - years{1}) / dec / thu[last]) + (mon - thu);
+    auto start = localizer_.ConvertDays((y - years{1}) / dec / thu[last]) + (mon - thu);
     if (t < start) {
       --y;
     }
     return static_cast<T>(static_cast<int32_t>(y));
   }
+
+  Localizer localizer_;
 };
 
 // ----------------------------------------------------------------------
@@ -206,64 +297,88 @@ struct ISOYear {
 // Last week of an ISO year has the year's last Thursday in it.
 // Based on
 // https://github.com/HowardHinnant/date/blob/6e921e1b1d21e84a5c82416ba7ecd98e33a436d0/include/date/iso_week.h#L1503
-template <typename Duration>
+
+template <typename Duration, typename Localizer>
 struct ISOWeek {
+  explicit ISOWeek(const FunctionOptions* options, Localizer&& localizer)
+      : localizer_(std::move(localizer)) {}
+
   template <typename T, typename Arg0>
-  static T Call(KernelContext*, Arg0 arg, Status*) {
-    const auto t = floor<days>(sys_time<Duration>(Duration{arg}));
+  T Call(KernelContext*, Arg0 arg, Status*) const {
+    const auto t = floor<days>(localizer_.template ConvertTimePoint<Duration>(arg));
     auto y = year_month_day{t + days{3}}.year();
-    auto start = sys_time<days>((y - years{1}) / dec / thu[last]) + (mon - thu);
+    auto start = localizer_.ConvertDays((y - years{1}) / dec / thu[last]) + (mon - thu);
     if (t < start) {
       --y;
-      start = sys_time<days>((y - years{1}) / dec / thu[last]) + (mon - thu);
+      start = localizer_.ConvertDays((y - years{1}) / dec / thu[last]) + (mon - thu);
     }
     return static_cast<T>(trunc<weeks>(t - start).count() + 1);
   }
+
+  Localizer localizer_;
 };
 
 // ----------------------------------------------------------------------
 // Extract quarter from timestamp
 
-template <typename Duration>
+template <typename Duration, typename Localizer>
 struct Quarter {
+  explicit Quarter(const FunctionOptions* options, Localizer&& localizer)
+      : localizer_(std::move(localizer)) {}
+
   template <typename T, typename Arg0>
-  static T Call(KernelContext*, Arg0 arg, Status*) {
-    const auto ymd = year_month_day(floor<days>(sys_time<Duration>(Duration{arg})));
+  T Call(KernelContext*, Arg0 arg, Status*) const {
+    const auto ymd =
+        year_month_day(floor<days>(localizer_.template ConvertTimePoint<Duration>(arg)));
     return static_cast<T>((static_cast<const uint32_t>(ymd.month()) - 1) / 3 + 1);
   }
+
+  Localizer localizer_;
 };
 
 // ----------------------------------------------------------------------
 // Extract hour from timestamp
 
-template <typename Duration>
+template <typename Duration, typename Localizer>
 struct Hour {
+  explicit Hour(const FunctionOptions* options, Localizer&& localizer)
+      : localizer_(std::move(localizer)) {}
+
   template <typename T, typename Arg0>
-  static T Call(KernelContext*, Arg0 arg, Status*) {
-    Duration t = Duration{arg};
+  T Call(KernelContext*, Arg0 arg, Status*) const {
+    const auto t = localizer_.template ConvertTimePoint<Duration>(arg);
     return static_cast<T>((t - floor<days>(t)) / std::chrono::hours(1));
   }
+
+  Localizer localizer_;
 };
 
 // ----------------------------------------------------------------------
 // Extract minute from timestamp
 
-template <typename Duration>
+template <typename Duration, typename Localizer>
 struct Minute {
+  explicit Minute(const FunctionOptions* options, Localizer&& localizer)
+      : localizer_(std::move(localizer)) {}
+
   template <typename T, typename Arg0>
-  static T Call(KernelContext*, Arg0 arg, Status*) {
-    Duration t = Duration{arg};
+  T Call(KernelContext*, Arg0 arg, Status*) const {
+    const auto t = localizer_.template ConvertTimePoint<Duration>(arg);
     return static_cast<T>((t - floor<std::chrono::hours>(t)) / std::chrono::minutes(1));
   }
+
+  Localizer localizer_;
 };
 
 // ----------------------------------------------------------------------
 // Extract second from timestamp
 
-template <typename Duration>
+template <typename Duration, typename Localizer>
 struct Second {
+  explicit Second(const FunctionOptions* options, Localizer&& localizer) {}
+
   template <typename T, typename Arg0>
-  static T Call(KernelContext*, Arg0 arg, Status*) {
+  T Call(KernelContext*, Arg0 arg, Status*) const {
     Duration t = Duration{arg};
     return static_cast<T>((t - floor<std::chrono::minutes>(t)) / std::chrono::seconds(1));
   }
@@ -272,8 +387,10 @@ struct Second {
 // ----------------------------------------------------------------------
 // Extract subsecond from timestamp
 
-template <typename Duration>
+template <typename Duration, typename Localizer>
 struct Subsecond {
+  explicit Subsecond(const FunctionOptions* options, Localizer&& localizer) {}
+
   template <typename T, typename Arg0>
   static T Call(KernelContext*, Arg0 arg, Status*) {
     Duration t = Duration{arg};
@@ -285,8 +402,10 @@ struct Subsecond {
 // ----------------------------------------------------------------------
 // Extract milliseconds from timestamp
 
-template <typename Duration>
+template <typename Duration, typename Localizer>
 struct Millisecond {
+  explicit Millisecond(const FunctionOptions* options, Localizer&& localizer) {}
+
   template <typename T, typename Arg0>
   static T Call(KernelContext*, Arg0 arg, Status*) {
     Duration t = Duration{arg};
@@ -298,8 +417,10 @@ struct Millisecond {
 // ----------------------------------------------------------------------
 // Extract microseconds from timestamp
 
-template <typename Duration>
+template <typename Duration, typename Localizer>
 struct Microsecond {
+  explicit Microsecond(const FunctionOptions* options, Localizer&& localizer) {}
+
   template <typename T, typename Arg0>
   static T Call(KernelContext*, Arg0 arg, Status*) {
     Duration t = Duration{arg};
@@ -311,8 +432,10 @@ struct Microsecond {
 // ----------------------------------------------------------------------
 // Extract nanoseconds from timestamp
 
-template <typename Duration>
+template <typename Duration, typename Localizer>
 struct Nanosecond {
+  explicit Nanosecond(const FunctionOptions* options, Localizer&& localizer) {}
+
   template <typename T, typename Arg0>
   static T Call(KernelContext*, Arg0 arg, Status*) {
     Duration t = Duration{arg};
@@ -321,40 +444,47 @@ struct Nanosecond {
   }
 };
 
-template <typename Duration>
-inline std::vector<int64_t> get_iso_calendar(int64_t arg) {
-  const auto t = floor<days>(sys_time<Duration>(Duration{arg}));
+// ----------------------------------------------------------------------
+// Extract ISO calendar values from timestamp
+
+template <typename Duration, typename Localizer>
+inline std::array<int64_t, 3> GetIsoCalendar(int64_t arg, Localizer&& localizer) {
+  const auto t = floor<days>(localizer.template ConvertTimePoint<Duration>(arg));
   const auto ymd = year_month_day(t);
   auto y = year_month_day{t + days{3}}.year();
-  auto start = sys_time<days>((y - years{1}) / dec / thu[last]) + (mon - thu);
+  auto start = localizer.ConvertDays((y - years{1}) / dec / thu[last]) + (mon - thu);
   if (t < start) {
     --y;
-    start = sys_time<days>((y - years{1}) / dec / thu[last]) + (mon - thu);
+    start = localizer.ConvertDays((y - years{1}) / dec / thu[last]) + (mon - thu);
   }
   return {static_cast<int64_t>(static_cast<int32_t>(y)),
           static_cast<int64_t>(trunc<weeks>(t - start).count() + 1),
           static_cast<int64_t>(weekday(ymd).iso_encoding())};
 }
 
-// ----------------------------------------------------------------------
-// Extract ISO calendar values from timestamp
-
 template <typename Duration>
 struct ISOCalendar {
   static Status Call(KernelContext* ctx, const Scalar& in, Scalar* out) {
-    RETURN_NOT_OK(TemporalComponentExtractCheckTimezone(in));
+    std::string timezone = GetInputTimezone(in);
+
     if (in.is_valid) {
-      const std::shared_ptr<DataType> iso_calendar_type =
-          struct_({field("iso_year", int64()), field("iso_week", int64()),
-                   field("iso_day_of_week", int64())});
       const auto& in_val = internal::UnboxScalar<const TimestampType>::Unbox(in);
-      const auto iso_calendar = get_iso_calendar<Duration>(in_val);
-
-      std::vector<std::shared_ptr<Scalar>> values = {
-          std::make_shared<Int64Scalar>(iso_calendar[0]),
-          std::make_shared<Int64Scalar>(iso_calendar[1]),
-          std::make_shared<Int64Scalar>(iso_calendar[2])};
-      *checked_cast<StructScalar*>(out) = StructScalar(values, iso_calendar_type);
+      std::array<int64_t, 3> iso_calendar;
+      if (timezone.empty()) {
+        iso_calendar = GetIsoCalendar<Duration>(in_val, NonZonedLocalizer{});
+      } else {
+        try {
+          const time_zone* tz = locate_zone(timezone);
+          iso_calendar = GetIsoCalendar<Duration>(in_val, ZonedLocalizer{tz});
+        } catch (const std::runtime_error& ex) {
+          return Status::Invalid(ex.what());
+        }
+      }
+      ScalarVector values = {std::make_shared<Int64Scalar>(iso_calendar[0]),
+                             std::make_shared<Int64Scalar>(iso_calendar[1]),
+                             std::make_shared<Int64Scalar>(iso_calendar[2])};
+      *checked_cast<StructScalar*>(out) =
+          StructScalar(std::move(values), IsoCalendarType());
     } else {
       out->is_valid = false;
     }
@@ -363,14 +493,10 @@ struct ISOCalendar {
 
   static Status Call(KernelContext* ctx, const ArrayData& in, ArrayData* out) {
     using BuilderType = typename TypeTraits<Int64Type>::BuilderType;
-
-    RETURN_NOT_OK(TemporalComponentExtractCheckTimezone(in));
-    const std::shared_ptr<DataType> iso_calendar_type =
-        struct_({field("iso_year", int64()), field("iso_week", int64()),
-                 field("iso_day_of_week", int64())});
+    std::string timezone = GetInputTimezone(in);
 
     std::unique_ptr<ArrayBuilder> array_builder;
-    RETURN_NOT_OK(MakeBuilder(ctx->memory_pool(), iso_calendar_type, &array_builder));
+    RETURN_NOT_OK(MakeBuilder(ctx->memory_pool(), IsoCalendarType(), &array_builder));
     StructBuilder* struct_builder = checked_cast<StructBuilder*>(array_builder.get());
     RETURN_NOT_OK(struct_builder->Reserve(in.length));
 
@@ -382,86 +508,70 @@ struct ISOCalendar {
       RETURN_NOT_OK(field_builders[i]->Reserve(1));
     }
     auto visit_null = [&]() { return struct_builder->AppendNull(); };
-    auto visit_value = [&](int64_t arg) {
-      const auto iso_calendar = get_iso_calendar<Duration>(arg);
-      field_builders[0]->UnsafeAppend(iso_calendar[0]);
-      field_builders[1]->UnsafeAppend(iso_calendar[1]);
-      field_builders[2]->UnsafeAppend(iso_calendar[2]);
-      return struct_builder->Append();
-    };
-    RETURN_NOT_OK(VisitArrayDataInline<Int64Type>(in, visit_value, visit_null));
+    if (timezone.empty()) {
+      auto visit_value = [&](int64_t arg) {
+        const auto iso_calendar = GetIsoCalendar<Duration>(arg, NonZonedLocalizer{});
+        field_builders[0]->UnsafeAppend(iso_calendar[0]);
+        field_builders[1]->UnsafeAppend(iso_calendar[1]);
+        field_builders[2]->UnsafeAppend(iso_calendar[2]);
+        return struct_builder->Append();
+      };
+      RETURN_NOT_OK(VisitArrayDataInline<Int64Type>(in, visit_value, visit_null));
+    } else {
+      try {
+        const time_zone* tz = locate_zone(timezone);
+        auto visit_value = [&](int64_t arg) {
+          const auto iso_calendar = GetIsoCalendar<Duration>(arg, ZonedLocalizer{tz});
+          field_builders[0]->UnsafeAppend(iso_calendar[0]);
+          field_builders[1]->UnsafeAppend(iso_calendar[1]);
+          field_builders[2]->UnsafeAppend(iso_calendar[2]);
+          return struct_builder->Append();
+        };
+        RETURN_NOT_OK(VisitArrayDataInline<Int64Type>(in, visit_value, visit_null));
+      } catch (const std::runtime_error& ex) {
+        return Status::Invalid(ex.what());
+      }
+    }
 
     std::shared_ptr<Array> out_array;
     RETURN_NOT_OK(struct_builder->Finish(&out_array));
     *out = *std::move(out_array->data());
-
     return Status::OK();
   }
 };
 
-template <template <typename...> class Op, typename OutType>
-std::shared_ptr<ScalarFunction> MakeTemporal(std::string name, const FunctionDoc* doc) {
-  const auto& out_type = TypeTraits<OutType>::type_singleton();
-  auto func = std::make_shared<ScalarFunction>(name, Arity::Unary(), doc);
-
-  for (auto unit : internal::AllTimeUnits()) {
-    InputType in_type{match::TimestampTypeUnit(unit)};
-    switch (unit) {
-      case TimeUnit::SECOND: {
-        auto exec = TemporalComponentExtract<Op<std::chrono::seconds>, OutType>::Exec;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec)));
-        break;
-      }
-      case TimeUnit::MILLI: {
-        auto exec =
-            TemporalComponentExtract<Op<std::chrono::milliseconds>, OutType>::Exec;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec)));
-        break;
-      }
-      case TimeUnit::MICRO: {
-        auto exec =
-            TemporalComponentExtract<Op<std::chrono::microseconds>, OutType>::Exec;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec)));
-        break;
-      }
-      case TimeUnit::NANO: {
-        auto exec = TemporalComponentExtract<Op<std::chrono::nanoseconds>, OutType>::Exec;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec)));
-        break;
-      }
-    }
-  }
-  return func;
-}
-
-template <template <typename...> class Op, typename OutType>
-std::shared_ptr<ScalarFunction> MakeTemporalWithOptions(
-    std::string name, const FunctionDoc* doc, const DayOfWeekOptions& default_options,
-    KernelInit init) {
-  const auto& out_type = TypeTraits<OutType>::type_singleton();
+template <
+    template <typename...> class Op,
+    template <template <typename...> class OpExec, typename Duration, typename OutType>
+    class ExecTemplate,
+    typename OutType>
+std::shared_ptr<ScalarFunction> MakeTemporal(
+    std::string name, const std::shared_ptr<arrow::DataType> out_type,
+    const FunctionDoc* doc, const FunctionOptions* default_options = NULLPTR,
+    KernelInit init = NULLPTR) {
   auto func =
-      std::make_shared<ScalarFunction>(name, Arity::Unary(), doc, &default_options);
+      std::make_shared<ScalarFunction>(name, Arity::Unary(), doc, default_options);
 
   for (auto unit : internal::AllTimeUnits()) {
     InputType in_type{match::TimestampTypeUnit(unit)};
     switch (unit) {
       case TimeUnit::SECOND: {
-        auto exec = DayOfWeekExec<Op<std::chrono::seconds>, OutType>::Exec;
+        auto exec = ExecTemplate<Op, std::chrono::seconds, OutType>::Exec;
         DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
         break;
       }
       case TimeUnit::MILLI: {
-        auto exec = DayOfWeekExec<Op<std::chrono::milliseconds>, OutType>::Exec;
+        auto exec = ExecTemplate<Op, std::chrono::milliseconds, OutType>::Exec;
         DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
         break;
       }
       case TimeUnit::MICRO: {
-        auto exec = DayOfWeekExec<Op<std::chrono::microseconds>, OutType>::Exec;
+        auto exec = ExecTemplate<Op, std::chrono::microseconds, OutType>::Exec;
         DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
         break;
       }
       case TimeUnit::NANO: {
-        auto exec = DayOfWeekExec<Op<std::chrono::nanoseconds>, OutType>::Exec;
+        auto exec = ExecTemplate<Op, std::chrono::nanoseconds, OutType>::Exec;
         DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
         break;
       }
@@ -471,33 +581,34 @@ std::shared_ptr<ScalarFunction> MakeTemporalWithOptions(
 }
 
 template <template <typename...> class Op>
-std::shared_ptr<ScalarFunction> MakeStructTemporal(std::string name,
-                                                   const FunctionDoc* doc) {
-  const auto& out_type = struct_({field("iso_year", int64()), field("iso_week", int64()),
-                                  field("iso_day_of_week", int64())});
-  auto func = std::make_shared<ScalarFunction>(name, Arity::Unary(), doc);
+std::shared_ptr<ScalarFunction> MakeSimpleUnaryTemporal(
+    std::string name, const std::shared_ptr<arrow::DataType> out_type,
+    const FunctionDoc* doc, const FunctionOptions* default_options = NULLPTR,
+    KernelInit init = NULLPTR) {
+  auto func =
+      std::make_shared<ScalarFunction>(name, Arity::Unary(), doc, default_options);
 
   for (auto unit : internal::AllTimeUnits()) {
     InputType in_type{match::TimestampTypeUnit(unit)};
     switch (unit) {
       case TimeUnit::SECOND: {
         auto exec = SimpleUnary<Op<std::chrono::seconds>>;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec)));
+        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
         break;
       }
       case TimeUnit::MILLI: {
         auto exec = SimpleUnary<Op<std::chrono::milliseconds>>;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec)));
+        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
         break;
       }
       case TimeUnit::MICRO: {
         auto exec = SimpleUnary<Op<std::chrono::microseconds>>;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec)));
+        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
         break;
       }
       case TimeUnit::NANO: {
         auto exec = SimpleUnary<Op<std::chrono::nanoseconds>>;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec)));
+        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
         break;
       }
     }
@@ -605,56 +716,71 @@ const FunctionDoc subsecond_doc{
 }  // namespace
 
 void RegisterScalarTemporal(FunctionRegistry* registry) {
-  auto year = MakeTemporal<Year, Int64Type>("year", &year_doc);
+  auto year =
+      MakeTemporal<Year, TemporalComponentExtract, Int64Type>("year", int64(), &year_doc);
   DCHECK_OK(registry->AddFunction(std::move(year)));
 
-  auto month = MakeTemporal<Month, Int64Type>("month", &year_doc);
+  auto month = MakeTemporal<Month, TemporalComponentExtract, Int64Type>("month", int64(),
+                                                                        &month_doc);
   DCHECK_OK(registry->AddFunction(std::move(month)));
 
-  auto day = MakeTemporal<Day, Int64Type>("day", &year_doc);
+  auto day =
+      MakeTemporal<Day, TemporalComponentExtract, Int64Type>("day", int64(), &day_doc);
   DCHECK_OK(registry->AddFunction(std::move(day)));
 
   static auto default_day_of_week_options = DayOfWeekOptions::Defaults();
-  auto day_of_week = MakeTemporalWithOptions<DayOfWeek, Int64Type>(
-      "day_of_week", &day_of_week_doc, default_day_of_week_options, DayOfWeekState::Init);
+  auto day_of_week =
+      MakeTemporal<DayOfWeek, TemporalComponentExtractDayOfWeek, Int64Type>(
+          "day_of_week", 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, Int64Type>("day_of_year", &day_of_year_doc);
+  auto day_of_year = MakeTemporal<DayOfYear, TemporalComponentExtract, Int64Type>(
+      "day_of_year", int64(), &day_of_year_doc);
   DCHECK_OK(registry->AddFunction(std::move(day_of_year)));
 
-  auto iso_year = MakeTemporal<ISOYear, Int64Type>("iso_year", &iso_year_doc);
+  auto iso_year = MakeTemporal<ISOYear, TemporalComponentExtract, Int64Type>(
+      "iso_year", int64(), &iso_year_doc);
   DCHECK_OK(registry->AddFunction(std::move(iso_year)));
 
-  auto iso_week = MakeTemporal<ISOWeek, Int64Type>("iso_week", &iso_week_doc);
+  auto iso_week = MakeTemporal<ISOWeek, TemporalComponentExtract, Int64Type>(
+      "iso_week", int64(), &iso_week_doc);
   DCHECK_OK(registry->AddFunction(std::move(iso_week)));
 
-  auto iso_calendar = MakeStructTemporal<ISOCalendar>("iso_calendar", &iso_calendar_doc);
+  auto iso_calendar = MakeSimpleUnaryTemporal<ISOCalendar>(
+      "iso_calendar", IsoCalendarType(), &iso_calendar_doc);
   DCHECK_OK(registry->AddFunction(std::move(iso_calendar)));
 
-  auto quarter = MakeTemporal<Quarter, Int64Type>("quarter", &quarter_doc);
+  auto quarter = MakeTemporal<Quarter, TemporalComponentExtract, Int64Type>(
+      "quarter", int64(), &quarter_doc);
   DCHECK_OK(registry->AddFunction(std::move(quarter)));
 
-  auto hour = MakeTemporal<Hour, Int64Type>("hour", &hour_doc);
+  auto hour =
+      MakeTemporal<Hour, TemporalComponentExtract, Int64Type>("hour", int64(), &hour_doc);
   DCHECK_OK(registry->AddFunction(std::move(hour)));
 
-  auto minute = MakeTemporal<Minute, Int64Type>("minute", &minute_doc);
+  auto minute = MakeTemporal<Minute, TemporalComponentExtract, Int64Type>(
+      "minute", int64(), &minute_doc);
   DCHECK_OK(registry->AddFunction(std::move(minute)));
 
-  auto second = MakeTemporal<Second, Int64Type>("second", &second_doc);
+  auto second = MakeTemporal<Second, TemporalComponentExtract, Int64Type>(
+      "second", int64(), &second_doc);
   DCHECK_OK(registry->AddFunction(std::move(second)));
 
-  auto millisecond =
-      MakeTemporal<Millisecond, Int64Type>("millisecond", &millisecond_doc);
+  auto millisecond = MakeTemporal<Millisecond, TemporalComponentExtract, Int64Type>(
+      "millisecond", int64(), &millisecond_doc);
   DCHECK_OK(registry->AddFunction(std::move(millisecond)));
 
-  auto microsecond =
-      MakeTemporal<Microsecond, Int64Type>("microsecond", &microsecond_doc);
+  auto microsecond = MakeTemporal<Microsecond, TemporalComponentExtract, Int64Type>(
+      "microsecond", int64(), &microsecond_doc);
   DCHECK_OK(registry->AddFunction(std::move(microsecond)));
 
-  auto nanosecond = MakeTemporal<Nanosecond, Int64Type>("nanosecond", &nanosecond_doc);
+  auto nanosecond = MakeTemporal<Nanosecond, TemporalComponentExtract, Int64Type>(
+      "nanosecond", int64(), &nanosecond_doc);
   DCHECK_OK(registry->AddFunction(std::move(nanosecond)));
 
-  auto subsecond = MakeTemporal<Subsecond, DoubleType>("subsecond", &subsecond_doc);
+  auto subsecond = MakeTemporal<Subsecond, TemporalComponentExtract, DoubleType>(
+      "subsecond", float64(), &subsecond_doc);
   DCHECK_OK(registry->AddFunction(std::move(subsecond)));
 }
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
index f2e9c12a050..fa00d985287 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
@@ -31,76 +31,75 @@ class ScalarTemporalTest : public ::testing::Test {
   const char* times =
       R"(["1970-01-01T00:00:59.123456789","2000-02-29T23:23:23.999999999",
           "1899-01-01T00:59:20.001001001","2033-05-18T03:33:20.000000000",
-          null, "2020-01-01T01:05:05.001", "2019-12-31T02:10:10.002",
+          "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"])";
+          "2008-12-28", "2008-12-29", "2012-01-01 01:02:03", null])";
   const char* times_seconds_precision =
       R"(["1970-01-01T00:00:59","2000-02-29T23:23:23",
           "1899-01-01T00:59:20","2033-05-18T03:33:20",
-          null, "2020-01-01T01:05:05", "2019-12-31T02:10:10",
+          "2020-01-01T01:05:05", "2019-12-31T02:10:10",
           "2019-12-30T03:15:15", "2009-12-31T04:20:20",
           "2010-01-01T05:25:25", "2010-01-03T06:30:30",
-          "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"])";
+          "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", null])";
   std::shared_ptr<arrow::DataType> iso_calendar_type =
       struct_({field("iso_year", int64()), field("iso_week", int64()),
                field("iso_day_of_week", int64())});
   std::shared_ptr<arrow::Array> iso_calendar =
       ArrayFromJSON(iso_calendar_type,
                     R"([{"iso_year": 1970, "iso_week": 1, "iso_day_of_week": 4},
-                          {"iso_year": 2000, "iso_week": 9, "iso_day_of_week": 2},
-                          {"iso_year": 1898, "iso_week": 52, "iso_day_of_week": 7},
-                          {"iso_year": 2033, "iso_week": 20, "iso_day_of_week": 3},
-                          null,
-                          {"iso_year": 2020, "iso_week": 1, "iso_day_of_week": 3},
-                          {"iso_year": 2020, "iso_week": 1, "iso_day_of_week": 2},
-                          {"iso_year": 2020, "iso_week": 1, "iso_day_of_week": 1},
-                          {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 4},
-                          {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 5},
-                          {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 7},
-                          {"iso_year": 2010, "iso_week": 1, "iso_day_of_week": 1},
-                          {"iso_year": 2005, "iso_week": 52, "iso_day_of_week": 7},
-                          {"iso_year": 2005, "iso_week": 52, "iso_day_of_week": 6},
-                          {"iso_year": 2008, "iso_week": 52, "iso_day_of_week": 7},
-                          {"iso_year": 2009, "iso_week": 1, "iso_day_of_week": 1},
-                          {"iso_year": 2011, "iso_week": 52, "iso_day_of_week": 7}])");
+                      {"iso_year": 2000, "iso_week": 9, "iso_day_of_week": 2},
+                      {"iso_year": 1898, "iso_week": 52, "iso_day_of_week": 7},
+                      {"iso_year": 2033, "iso_week": 20, "iso_day_of_week": 3},
+                      {"iso_year": 2020, "iso_week": 1, "iso_day_of_week": 3},
+                      {"iso_year": 2020, "iso_week": 1, "iso_day_of_week": 2},
+                      {"iso_year": 2020, "iso_week": 1, "iso_day_of_week": 1},
+                      {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 4},
+                      {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 5},
+                      {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 7},
+                      {"iso_year": 2010, "iso_week": 1, "iso_day_of_week": 1},
+                      {"iso_year": 2005, "iso_week": 52, "iso_day_of_week": 7},
+                      {"iso_year": 2005, "iso_week": 52, "iso_day_of_week": 6},
+                      {"iso_year": 2008, "iso_week": 52, "iso_day_of_week": 7},
+                      {"iso_year": 2009, "iso_week": 1, "iso_day_of_week": 1},
+                      {"iso_year": 2011, "iso_week": 52, "iso_day_of_week": 7}, null])");
   std::string year =
-      "[1970, 2000, 1899, 2033, null, 2020, 2019, 2019, 2009, 2010, 2010, 2010, 2006, "
-      "2005, 2008, 2008, 2012]";
-  std::string month = "[1, 2, 1, 5, null, 1, 12, 12, 12, 1, 1, 1, 1, 12, 12, 12, 1]";
-  std::string day = "[1, 29, 1, 18, null, 1, 31, 30, 31, 1, 3, 4, 1, 31, 28, 29, 1]";
-  std::string day_of_week = "[3, 1, 6, 2, null, 2, 1, 0, 3, 4, 6, 0, 6, 5, 6, 0, 6]";
+      "[1970, 2000, 1899, 2033, 2020, 2019, 2019, 2009, 2010, 2010, 2010, 2006, "
+      "2005, 2008, 2008, 2012, null]";
+  std::string month = "[1, 2, 1, 5, 1, 12, 12, 12, 1, 1, 1, 1, 12, 12, 12, 1, null]";
+  std::string day = "[1, 29, 1, 18, 1, 31, 30, 31, 1, 3, 4, 1, 31, 28, 29, 1, null]";
+  std::string day_of_week = "[3, 1, 6, 2, 2, 1, 0, 3, 4, 6, 0, 6, 5, 6, 0, 6, null]";
   std::string day_of_year =
-      "[1, 60, 1, 138, null, 1, 365, 364, 365, 1, 3, 4, 1, 365, 363, 364, 1]";
+      "[1, 60, 1, 138, 1, 365, 364, 365, 1, 3, 4, 1, 365, 363, 364, 1, null]";
   std::string iso_year =
-      "[1970, 2000, 1898, 2033, null, 2020, 2020, 2020, 2009, 2009, 2009, 2010, 2005, "
-      "2005, 2008, 2009, 2011]";
+      "[1970, 2000, 1898, 2033, 2020, 2020, 2020, 2009, 2009, 2009, 2010, 2005, "
+      "2005, 2008, 2009, 2011, null]";
   std::string iso_week =
-      "[1, 9, 52, 20, null, 1, 1, 1, 53, 53, 53, 1, 52, 52, 52, 1, 52]";
+      "[1, 9, 52, 20, 1, 1, 1, 53, 53, 53, 1, 52, 52, 52, 1, 52, null]";
 
-  std::string quarter = "[1, 1, 1, 2, null, 1, 4, 4, 4, 1, 1, 1, 1, 4, 4, 4, 1]";
-  std::string hour = "[0, 23, 0, 3, null, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1]";
+  std::string quarter = "[1, 1, 1, 2, 1, 4, 4, 4, 1, 1, 1, 1, 4, 4, 4, 1, null]";
+  std::string hour = "[0, 23, 0, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1, null]";
   std::string minute =
-      "[0, 23, 59, 33, null, 5, 10, 15, 20, 25, 30, 35, 40, 45, 0, 0, 2]";
+      "[0, 23, 59, 33, 5, 10, 15, 20, 25, 30, 35, 40, 45, 0, 0, 2, null]";
   std::string second =
-      "[59, 23, 20, 20, null, 5, 10, 15, 20, 25, 30, 35, 40, 45, 0, 0, 3]";
-  std::string millisecond = "[123, 999, 1, 0, null, 1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0, 0]";
+      "[59, 23, 20, 20, 5, 10, 15, 20, 25, 30, 35, 40, 45, 0, 0, 3, null]";
+  std::string millisecond = "[123, 999, 1, 0, 1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0, 0, null]";
   std::string microsecond =
-      "[456, 999, 1, 0, null, 0, 0, 0, 132, 321, 163, 0, 0, 0, 0, 0, 0]";
-  std::string nanosecond = "[789, 999, 1, 0, null, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]";
+      "[456, 999, 1, 0, 0, 0, 0, 132, 321, 163, 0, 0, 0, 0, 0, 0, null]";
+  std::string nanosecond = "[789, 999, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, null]";
   std::string subsecond =
-      "[0.123456789, 0.999999999, 0.001001001, 0, null, 0.001, 0.002, 0.003, 0.004132, "
-      "0.005321, 0.006163, 0, 0, 0, 0, 0, 0]";
-  std::string zeros = "[0, 0, 0, 0, null, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]";
+      "[0.123456789, 0.999999999, 0.001001001, 0, 0.001, 0.002, 0.003, 0.004132, "
+      "0.005321, 0.006163, 0, 0, 0, 0, 0, 0, null]";
+  std::string zeros = "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, null]";
 };
 
 namespace compute {
 
 TEST_F(ScalarTemporalTest, TestTemporalComponentExtraction) {
   auto unit = timestamp(TimeUnit::NANO);
-
   CheckScalarUnary("year", unit, times, int64(), year);
   CheckScalarUnary("month", unit, times, int64(), month);
   CheckScalarUnary("day", unit, times, int64(), day);
@@ -142,44 +141,211 @@ TEST_F(ScalarTemporalTest, TestTemporalComponentExtractionWithDifferentUnits) {
   }
 }
 
-TEST_F(ScalarTemporalTest, TestZonedTemporalComponentExtraction) {
-  std::string timezone = "Asia/Kolkata";
+TEST_F(ScalarTemporalTest, TestOutsideNanosecondRange) {
+  const char* times = R"(["1677-09-20T00:00:59.123456", "2262-04-13T23:23:23.999999"])";
+
+  auto unit = timestamp(TimeUnit::MICRO);
+  auto iso_calendar_type =
+      struct_({field("iso_year", int64()), field("iso_week", int64()),
+               field("iso_day_of_week", int64())});
+
+  auto year = "[1677, 2262]";
+  auto month = "[9, 4]";
+  auto day = "[20, 13]";
+  auto day_of_week = "[0, 6]";
+  auto day_of_year = "[263, 103]";
+  auto iso_year = "[1677, 2262]";
+  auto iso_week = "[38, 15]";
+  auto iso_calendar =
+      ArrayFromJSON(iso_calendar_type,
+                    R"([{"iso_year": 1677, "iso_week": 38, "iso_day_of_week": 1},
+                          {"iso_year": 2262, "iso_week": 15, "iso_day_of_week": 7}])");
+  auto quarter = "[3, 2]";
+  auto hour = "[0, 23]";
+  auto minute = "[0, 23]";
+  auto second = "[59, 23]";
+  auto millisecond = "[123, 999]";
+  auto microsecond = "[456, 999]";
+  auto nanosecond = "[0, 0]";
+  auto subsecond = "[0.123456, 0.999999]";
+
+  CheckScalarUnary("year", unit, times, int64(), year);
+  CheckScalarUnary("month", unit, times, int64(), month);
+  CheckScalarUnary("day", unit, times, int64(), day);
+  CheckScalarUnary("day_of_week", unit, times, int64(), day_of_week);
+  CheckScalarUnary("day_of_year", unit, times, int64(), day_of_year);
+  CheckScalarUnary("iso_year", unit, times, int64(), iso_year);
+  CheckScalarUnary("iso_week", unit, times, int64(), iso_week);
+  CheckScalarUnary("iso_calendar", ArrayFromJSON(unit, times), iso_calendar);
+  CheckScalarUnary("quarter", unit, times, int64(), quarter);
+  CheckScalarUnary("hour", unit, times, int64(), hour);
+  CheckScalarUnary("minute", unit, times, int64(), minute);
+  CheckScalarUnary("second", unit, times, int64(), second);
+  CheckScalarUnary("millisecond", unit, times, int64(), millisecond);
+  CheckScalarUnary("microsecond", unit, times, int64(), microsecond);
+  CheckScalarUnary("nanosecond", unit, times, int64(), nanosecond);
+  CheckScalarUnary("subsecond", unit, times, float64(), subsecond);
+}
+
+#ifndef _WIN32
+// TODO: We should test on windows once ARROW-13168 is resolved.
+TEST_F(ScalarTemporalTest, TestZoned1) {
+  auto unit = timestamp(TimeUnit::NANO, "Pacific/Marquesas");
+  auto iso_calendar_type =
+      struct_({field("iso_year", int64()), field("iso_week", int64()),
+               field("iso_day_of_week", int64())});
+  auto year =
+      "[1969, 2000, 1898, 2033, 2019, 2019, 2019, 2009, 2009, 2010, 2010, 2005, 2005, "
+      "2008, 2008, 2011, null]";
+  auto month = "[12, 2, 12, 5, 12, 12, 12, 12, 12, 1, 1, 12, 12, 12, 12, 12, null]";
+  auto day = "[31, 29, 31, 17, 31, 30, 29, 30, 31, 2, 3, 31, 31, 27, 28, 31, null]";
+  auto day_of_week = "[2, 1, 5, 1, 1, 0, 6, 2, 3, 5, 6, 5, 5, 5, 6, 5, null]";
+  auto day_of_year =
+      "[365, 60, 365, 137, 365, 364, 363, 364, 365, 2, 3, 365, 365, 362, 363, 365, null]";
+  auto iso_year =
+      "[1970, 2000, 1898, 2033, 2020, 2020, 2019, 2009, 2009, 2009, 2009, 2005, 2005, "
+      "2008, 2008, 2011, null]";
+  auto iso_week = "[1, 9, 52, 20, 1, 1, 52, 53, 53, 53, 53, 52, 52, 52, 52, 52, null]";
+  auto iso_calendar =
+      ArrayFromJSON(iso_calendar_type,
+                    R"([{"iso_year": 1970, "iso_week": 1, "iso_day_of_week": 3},
+                        {"iso_year": 2000, "iso_week": 9, "iso_day_of_week": 2},
+                        {"iso_year": 1898, "iso_week": 52, "iso_day_of_week": 6},
+                        {"iso_year": 2033, "iso_week": 20, "iso_day_of_week": 2},
+                        {"iso_year": 2020, "iso_week": 1, "iso_day_of_week": 2},
+                        {"iso_year": 2020, "iso_week": 1, "iso_day_of_week": 1},
+                        {"iso_year": 2019, "iso_week": 52, "iso_day_of_week": 7},
+                        {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 3},
+                        {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 4},
+                        {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 6},
+                        {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 7},
+                        {"iso_year": 2005, "iso_week": 52, "iso_day_of_week": 6},
+                        {"iso_year": 2005, "iso_week": 52, "iso_day_of_week": 6},
+                        {"iso_year": 2008, "iso_week": 52, "iso_day_of_week": 6},
+                        {"iso_year": 2008, "iso_week": 52, "iso_day_of_week": 7},
+                        {"iso_year": 2011, "iso_week": 52, "iso_day_of_week": 6}, null])");
+  auto quarter = "[4, 1, 4, 2, 4, 4, 4, 4, 4, 1, 1, 4, 4, 4, 4, 4, null]";
+  auto hour = "[14, 13, 15, 18, 15, 16, 17, 18, 19, 21, 22, 23, 0, 14, 14, 15, null]";
+  auto minute = "[30, 53, 41, 3, 35, 40, 45, 50, 55, 0, 5, 10, 15, 30, 30, 32, null]";
+
+  CheckScalarUnary("year", unit, times, int64(), year);
+  CheckScalarUnary("month", unit, times, int64(), month);
+  CheckScalarUnary("day", unit, times, int64(), day);
+  CheckScalarUnary("day_of_week", unit, times, int64(), day_of_week);
+  CheckScalarUnary("day_of_year", unit, times, int64(), day_of_year);
+  CheckScalarUnary("iso_year", unit, times, int64(), iso_year);
+  CheckScalarUnary("iso_week", unit, times, int64(), iso_week);
+  CheckScalarUnary("iso_calendar", ArrayFromJSON(unit, times), iso_calendar);
+  CheckScalarUnary("quarter", unit, times, int64(), quarter);
+  CheckScalarUnary("hour", unit, times, int64(), hour);
+  CheckScalarUnary("minute", unit, times, int64(), minute);
+  CheckScalarUnary("second", unit, times, int64(), second);
+  CheckScalarUnary("millisecond", unit, times, int64(), millisecond);
+  CheckScalarUnary("microsecond", unit, times, int64(), microsecond);
+  CheckScalarUnary("nanosecond", unit, times, int64(), nanosecond);
+  CheckScalarUnary("subsecond", unit, times, float64(), subsecond);
+}
+
+TEST_F(ScalarTemporalTest, TestZoned2) {
+  for (auto u : internal::AllTimeUnits()) {
+    auto unit = timestamp(u, "Australia/Broken_Hill");
+    auto iso_calendar_type =
+        struct_({field("iso_year", int64()), field("iso_week", int64()),
+                 field("iso_day_of_week", int64())});
+    auto year =
+        "[1970, 2000, 1899, 2033, 2020, 2019, 2019, 2009, 2010, 2010, 2010, 2006, 2005, "
+        "2008, 2008, 2012, null]";
+    auto month = "[1, 3, 1, 5, 1, 12, 12, 12, 1, 1, 1, 1, 12, 12, 12, 1, null]";
+    auto day = "[1, 1, 1, 18, 1, 31, 30, 31, 1, 3, 4, 1, 31, 28, 29, 1, null]";
+    auto day_of_week = "[3, 2, 6, 2, 2, 1, 0, 3, 4, 6, 0, 6, 5, 6, 0, 6, null]";
+    auto day_of_year =
+        "[1, 61, 1, 138, 1, 365, 364, 365, 1, 3, 4, 1, 365, 363, 364, 1, null]";
+    auto iso_year =
+        "[1970, 2000, 1898, 2033, 2020, 2020, 2020, 2009, 2009, 2009, 2010, 2005, 2005, "
+        "2008, 2009, 2011, null]";
+    auto iso_week = "[1, 9, 52, 20, 1, 1, 1, 53, 53, 53, 1, 52, 52, 52, 1, 52, null]";
+    auto iso_calendar =
+        ArrayFromJSON(iso_calendar_type,
+                      R"([{"iso_year": 1970, "iso_week": 1, "iso_day_of_week": 4},
+                          {"iso_year": 2000, "iso_week": 9, "iso_day_of_week": 3},
+                          {"iso_year": 1898, "iso_week": 52, "iso_day_of_week": 7},
+                          {"iso_year": 2033, "iso_week": 20, "iso_day_of_week": 3},
+                          {"iso_year": 2020, "iso_week": 1, "iso_day_of_week": 3},
+                          {"iso_year": 2020, "iso_week": 1, "iso_day_of_week": 2},
+                          {"iso_year": 2020, "iso_week": 1, "iso_day_of_week": 1},
+                          {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 4},
+                          {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 5},
+                          {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 7},
+                          {"iso_year": 2010, "iso_week": 1, "iso_day_of_week": 1},
+                          {"iso_year": 2005, "iso_week": 52, "iso_day_of_week": 7},
+                          {"iso_year": 2005, "iso_week": 52, "iso_day_of_week": 6},
+                          {"iso_year": 2008, "iso_week": 52, "iso_day_of_week": 7},
+                          {"iso_year": 2009, "iso_week": 1, "iso_day_of_week": 1},
+                          {"iso_year": 2011, "iso_week": 52, "iso_day_of_week": 7}, null])");
+    auto quarter = "[1, 1, 1, 2, 1, 4, 4, 4, 1, 1, 1, 1, 4, 4, 4, 1, null]";
+    auto hour = "[9, 9, 9, 13, 11, 12, 13, 14, 15, 17, 18, 19, 20, 10, 10, 11, null]";
+    auto minute = "[30, 53, 59, 3, 35, 40, 45, 50, 55, 0, 5, 10, 15, 30, 30, 32, null]";
+
+    CheckScalarUnary("year", unit, times_seconds_precision, int64(), year);
+    CheckScalarUnary("month", unit, times_seconds_precision, int64(), month);
+    CheckScalarUnary("day", unit, times_seconds_precision, int64(), day);
+    CheckScalarUnary("day_of_week", unit, times_seconds_precision, int64(), day_of_week);
+    CheckScalarUnary("day_of_year", unit, times_seconds_precision, int64(), day_of_year);
+    CheckScalarUnary("iso_year", unit, times_seconds_precision, int64(), iso_year);
+    CheckScalarUnary("iso_week", unit, times_seconds_precision, int64(), iso_week);
+    CheckScalarUnary("iso_calendar", ArrayFromJSON(unit, times_seconds_precision),
+                     iso_calendar);
+    CheckScalarUnary("quarter", unit, times_seconds_precision, int64(), quarter);
+    CheckScalarUnary("hour", unit, times_seconds_precision, int64(), hour);
+    CheckScalarUnary("minute", unit, times_seconds_precision, int64(), minute);
+    CheckScalarUnary("second", unit, times_seconds_precision, int64(), second);
+    CheckScalarUnary("millisecond", unit, times_seconds_precision, int64(), zeros);
+    CheckScalarUnary("microsecond", unit, times_seconds_precision, int64(), zeros);
+    CheckScalarUnary("nanosecond", unit, times_seconds_precision, int64(), zeros);
+    CheckScalarUnary("subsecond", unit, times_seconds_precision, float64(), zeros);
+  }
+}
+
+TEST_F(ScalarTemporalTest, TestNonexistentTimezone) {
+  auto data_buffer = Buffer::Wrap(std::vector<int32_t>{1, 2, 3});
+  auto null_buffer = Buffer::FromString("\xff");
 
   for (auto u : internal::AllTimeUnits()) {
-    auto unit = timestamp(u, timezone);
-    auto timestamps = ArrayFromJSON(unit, times_seconds_precision);
-
-    ASSERT_RAISES(NotImplemented, Year(timestamps));
-    ASSERT_RAISES(NotImplemented, Month(timestamps));
-    ASSERT_RAISES(NotImplemented, Day(timestamps));
-    ASSERT_RAISES(NotImplemented, DayOfWeek(timestamps));
-    ASSERT_RAISES(NotImplemented, DayOfYear(timestamps));
-    ASSERT_RAISES(NotImplemented, ISOYear(timestamps));
-    ASSERT_RAISES(NotImplemented, ISOWeek(timestamps));
-    ASSERT_RAISES(NotImplemented, ISOCalendar(timestamps));
-    ASSERT_RAISES(NotImplemented, Quarter(timestamps));
-    ASSERT_RAISES(NotImplemented, Hour(timestamps));
-    ASSERT_RAISES(NotImplemented, Minute(timestamps));
-    ASSERT_RAISES(NotImplemented, Second(timestamps));
-    ASSERT_RAISES(NotImplemented, Millisecond(timestamps));
-    ASSERT_RAISES(NotImplemented, Microsecond(timestamps));
-    ASSERT_RAISES(NotImplemented, Nanosecond(timestamps));
-    ASSERT_RAISES(NotImplemented, Subsecond(timestamps));
+    auto ts_type = timestamp(u, "Mars/Mariner_Valley");
+    auto timestamp_array = std::make_shared<NumericArray<TimestampType>>(
+        ts_type, 2, data_buffer, null_buffer, 0);
+    ASSERT_RAISES(Invalid, Year(timestamp_array));
+    ASSERT_RAISES(Invalid, Month(timestamp_array));
+    ASSERT_RAISES(Invalid, Day(timestamp_array));
+    ASSERT_RAISES(Invalid, DayOfWeek(timestamp_array));
+    ASSERT_RAISES(Invalid, DayOfYear(timestamp_array));
+    ASSERT_RAISES(Invalid, ISOYear(timestamp_array));
+    ASSERT_RAISES(Invalid, ISOWeek(timestamp_array));
+    ASSERT_RAISES(Invalid, ISOCalendar(timestamp_array));
+    ASSERT_RAISES(Invalid, Quarter(timestamp_array));
+    ASSERT_RAISES(Invalid, Hour(timestamp_array));
+    ASSERT_RAISES(Invalid, Minute(timestamp_array));
+    ASSERT_RAISES(Invalid, Second(timestamp_array));
+    ASSERT_RAISES(Invalid, Millisecond(timestamp_array));
+    ASSERT_RAISES(Invalid, Microsecond(timestamp_array));
+    ASSERT_RAISES(Invalid, Nanosecond(timestamp_array));
+    ASSERT_RAISES(Invalid, Subsecond(timestamp_array));
   }
 }
+#endif
 
 TEST_F(ScalarTemporalTest, DayOfWeek) {
   auto unit = timestamp(TimeUnit::NANO);
 
   auto timestamps = ArrayFromJSON(unit, times);
   auto day_of_week_week_start_7_zero_based =
-      "[4, 2, 0, 3, null, 3, 2, 1, 4, 5, 0, 1, 0, 6, 0, 1, 0]";
+      "[4, 2, 0, 3, 3, 2, 1, 4, 5, 0, 1, 0, 6, 0, 1, 0, null]";
   auto day_of_week_week_start_2_zero_based =
-      "[2, 0, 5, 1, null, 1, 0, 6, 2, 3, 5, 6, 5, 4, 5, 6, 5]";
+      "[2, 0, 5, 1, 1, 0, 6, 2, 3, 5, 6, 5, 4, 5, 6, 5, null]";
   auto day_of_week_week_start_7_one_based =
-      "[5, 3, 1, 4, null, 4, 3, 2, 5, 6, 1, 2, 1, 7, 1, 2, 1]";
+      "[5, 3, 1, 4, 4, 3, 2, 5, 6, 1, 2, 1, 7, 1, 2, 1, null]";
   auto day_of_week_week_start_2_one_based =
-      "[3, 1, 6, 2, null, 2, 1, 7, 3, 4, 6, 7, 6, 5, 6, 7, 6]";
+      "[3, 1, 6, 2, 2, 1, 7, 3, 4, 6, 7, 6, 5, 6, 7, 6, null]";
 
   auto expected_70 = ArrayFromJSON(int64(), day_of_week_week_start_7_zero_based);
   ASSERT_OK_AND_ASSIGN(
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index d429b6cfecd..39bbbec3e16 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1083,42 +1083,42 @@ Temporal component extraction
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 These functions extract datetime components (year, month, day, etc) from timestamp type.
-Note: this is currently not supported for timestamps with timezone information.
+If the input timestamps have a non-empty timezone, localized timestamp components will be returned.
 
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
 | Function name      | Arity      | Input types       | Output type   | Options class              | Notes |
 +====================+============+===================+===============+============================+=======+
-| year               | Unary      | Temporal          | Int64         |                            |       |
+| year               | Unary      | Timestamp         | Int64         |                            |       |
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
-| month              | Unary      | Temporal          | Int64         |                            |       |
+| month              | Unary      | Timestamp         | Int64         |                            |       |
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
-| day                | Unary      | Temporal          | Int64         |                            |       |
+| day                | Unary      | Timestamp         | Int64         |                            |       |
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
-| day_of_week        | Unary      | Temporal          | Int64         | :struct:`DayOfWeekOptions` | \(1)  |
+| day_of_week        | Unary      | Timestamp         | Int64         | :struct:`DayOfWeekOptions` | \(1)  |
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
-| day_of_year        | Unary      | Temporal          | Int64         |                            |       |
+| day_of_year        | Unary      | Timestamp         | Int64         |                            |       |
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
-| iso_year           | Unary      | Temporal          | Int64         |                            | \(2)  |
+| iso_year           | Unary      | Timestamp         | Int64         |                            | \(2)  |
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
-| iso_week           | Unary      | Temporal          | Int64         |                            | \(2)  |
+| iso_week           | Unary      | Timestamp         | Int64         |                            | \(2)  |
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
-| iso_calendar       | Unary      | Temporal          | Struct        |                            | \(3)  |
+| iso_calendar       | Unary      | Timestamp         | Struct        |                            | \(3)  |
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
-| quarter            | Unary      | Temporal          | Int64         |                            |       |
+| quarter            | Unary      | Timestamp         | Int64         |                            |       |
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
-| hour               | Unary      | Temporal          | Int64         |                            |       |
+| hour               | Unary      | Timestamp         | Int64         |                            |       |
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
-| minute             | Unary      | Temporal          | Int64         |                            |       |
+| minute             | Unary      | Timestamp         | Int64         |                            |       |
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
-| second             | Unary      | Temporal          | Int64         |                            |       |
+| second             | Unary      | Timestamp         | Int64         |                            |       |
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
-| millisecond        | Unary      | Temporal          | Int64         |                            |       |
+| millisecond        | Unary      | Timestamp         | Int64         |                            |       |
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
-| microsecond        | Unary      | Temporal          | Int64         |                            |       |
+| microsecond        | Unary      | Timestamp         | Int64         |                            |       |
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
-| nanosecond         | Unary      | Temporal          | Int64         |                            |       |
+| nanosecond         | Unary      | Timestamp         | Int64         |                            |       |
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
-| subsecond          | Unary      | Temporal          | Double        |                            |       |
+| subsecond          | Unary      | Timestamp         | Double        |                            |       |
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
 
 * \(1) Outputs the number of the day of the week. By default week begins on Monday
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 60a2f60f942..26d1f0e647c 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -21,6 +21,7 @@
 import pickle
 import pytest
 import random
+import sys
 import textwrap
 
 import numpy as np
@@ -1365,8 +1366,9 @@ def test_strptime():
 def _check_datetime_components(timestamps, timezone=None):
     from pyarrow.vendored.version import Version
 
-    ts = pd.to_datetime(timestamps).to_series()
-    tsa = pa.array(ts)
+    ts = pd.to_datetime(timestamps).tz_localize(
+        "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)
@@ -1412,11 +1414,13 @@ def _check_datetime_components(timestamps, timezone=None):
     day_of_week_options = pc.DayOfWeekOptions(
         one_based_numbering=True, week_start=1)
     assert pc.day_of_week(tsa, options=day_of_week_options).equals(
-        pa.array(ts.dt.dayofweek+1))
+        pa.array(ts.dt.dayofweek + 1))
 
 
 @pytest.mark.pandas
 def test_extract_datetime_components():
+    from pyarrow.vendored.version import Version
+
     timestamps = ["1970-01-01T00:00:59.123456789",
                   "2000-02-29T23:23:23.999999999",
                   "2033-05-18T03:33:20.000000000",
@@ -1432,9 +1436,22 @@ def test_extract_datetime_components():
                   "2008-12-28",
                   "2008-12-29",
                   "2012-01-01 01:02:03"]
+    timezones = ["UTC", "US/Central", "Asia/Kolkata",
+                 "Etc/GMT-4", "Etc/GMT+4", "Australia/Broken_Hill"]
 
+    # Test timezone naive timestamp array
     _check_datetime_components(timestamps)
 
+    # Test timezone aware timestamp array
+    if sys.platform == 'win32':
+        # TODO: We should test on windows once ARROW-13168 is resolved.
+        pytest.skip('Timezone database is not available on Windows yet')
+    elif Version(pd.__version__) <= Version('0.23.0'):
+        pytest.skip('Pandas 0.23.0 extracts time components incorrectly.')
+    else:
+        for timezone in timezones:
+            _check_datetime_components(timestamps, timezone)
+
 
 def test_count():
     arr = pa.array([1, 2, 3, None, None])
diff --git a/r/configure.win b/r/configure.win
index f31bf8f9cf4..d830a238c39 100644
--- a/r/configure.win
+++ b/r/configure.win
@@ -50,7 +50,7 @@ AWS_LIBS="-laws-cpp-sdk-config -laws-cpp-sdk-transfer -laws-cpp-sdk-identity-man
 # NOTE: If you make changes to the libraries below, you should also change
 # ci/scripts/r_windows_build.sh and ci/scripts/PKGBUILD
 PKG_CFLAGS="-I${RWINLIB}/include -DARROW_STATIC -DPARQUET_STATIC -DARROW_DS_STATIC -DARROW_R_WITH_ARROW -DARROW_R_WITH_PARQUET -DARROW_R_WITH_DATASET"
-PKG_LIBS="-L${RWINLIB}/lib"'$(subst gcc,,$(COMPILED_BY))$(R_ARCH) '"-L${RWINLIB}/lib"'$(R_ARCH)$(CRT) '"-lparquet -larrow_dataset -larrow -larrow_bundled_dependencies -lutf8proc -lthrift -lsnappy -lz -lzstd -llz4 ${MIMALLOC_LIBS} ${OPENSSL_LIBS}"
+PKG_LIBS="-L${RWINLIB}/lib"'$(subst gcc,,$(COMPILED_BY))$(R_ARCH) '"-L${RWINLIB}/lib"'$(R_ARCH)$(CRT) '"-lparquet -larrow_dataset -larrow -larrow_bundled_dependencies -lutf8proc -lthrift -lsnappy -lz -lzstd -llz4 -lole32 ${MIMALLOC_LIBS} ${OPENSSL_LIBS}"
 
 # S3 and re2 support only for Rtools40 (i.e. R >= 4.0)
 "${R_HOME}/bin${R_ARCH_BIN}/Rscript.exe" -e 'R.version$major >= 4' | grep TRUE >/dev/null 2>&1
diff --git a/r/tests/testthat/test-dplyr-lubridate.R b/r/tests/testthat/test-dplyr-lubridate.R
index cedbe064ba1..d216ec82c1e 100644
--- a/r/tests/testthat/test-dplyr-lubridate.R
+++ b/r/tests/testthat/test-dplyr-lubridate.R
@@ -26,22 +26,13 @@ library(dplyr)
 # TODO: consider reevaluating this workaround after ARROW-12980
 withr::local_timezone("UTC")
 
-test_date <- as.POSIXct("2017-01-01 00:00:12.3456789", tz = "")
+if (tolower(Sys.info()[["sysname"]]) == "windows") {
+  test_date <- as.POSIXct("2017-01-01 00:00:12.3456789", tz = "")
+} else {
+  test_date <- as.POSIXct("2017-01-01 00:00:12.3456789", tz = "Pacific/Marquesas")
+}
 test_df <- tibble::tibble(date = test_date)
 
-# We can support this feature after ARROW-12980 is merged
-test_that("timezone aware timestamps are not supported", {
-  tz_aware_date <- as.POSIXct("2017-01-01 00:00:12.3456789", tz = "Pacific/Marquesas")
-  tz_aware_df <- tibble::tibble(date = tz_aware_date)
-
-  expect_error(
-    Table$create(tz_aware_df) %>%
-      mutate(x = wday(date)) %>%
-      collect(),
-    "Cannot extract components from timestamp with specific timezone"
-  )
-})
-
 # We can support this feature when ARROW-13138 is resolved
 test_that("date32 objects are not supported", {
   date <- ymd("2017-01-01")
@@ -61,8 +52,7 @@ test_that("extract year from date", {
     input %>%
       mutate(x = year(date)) %>%
       collect(),
-    test_df,
-    check.tzone = FALSE
+    test_df
   )
 })