GH-30036: [C++] Timezone-aware kernels should handle offset strings (e.g. "+04:30")

cpp/src/arrow/CMakeLists.txt

@@ -735,6 +735,7 @@ set(ARROW_COMPUTE_SRCS
     compute/kernels/scalar_cast_numeric.cc
     compute/kernels/scalar_cast_string.cc
     compute/kernels/scalar_cast_temporal.cc
+    compute/kernels/temporal_internal.cc
     compute/kernels/vector_hash.cc
     compute/kernels/vector_selection.cc
     compute/kernels/vector_selection_filter_internal.cc
@@ -779,6 +780,7 @@ if(ARROW_COMPUTE)
        compute/kernels/scalar_temporal_binary.cc
        compute/kernels/scalar_temporal_unary.cc
        compute/kernels/scalar_validity.cc
+       compute/kernels/temporal_internal.cc
        compute/kernels/util_internal.cc
        compute/kernels/vector_array_sort.cc
        compute/kernels/vector_cumulative_ops.cc

cpp/src/arrow/compute/kernels/scalar_cast_string.cc

@@ -196,8 +196,8 @@ struct TemporalToStringCastFunctor<O, TimestampType> {
     static const std::string kFormatString = "%Y-%m-%d %H:%M:%S%z";
     static const std::string kUtcFormatString = "%Y-%m-%d %H:%M:%SZ";
     DCHECK(!timezone.empty());
-    ARROW_ASSIGN_OR_RAISE(const time_zone* tz, LocateZone(timezone));
-    ARROW_ASSIGN_OR_RAISE(std::locale locale, GetLocale("C"));
+    ARROW_ASSIGN_OR_RAISE(auto tz, LocateZone(timezone));
+    ARROW_ASSIGN_OR_RAISE(auto locale, GetLocale("C"));
     TimestampFormatter<Duration> formatter{
         timezone == "UTC" ? kUtcFormatString : kFormatString, tz, locale};
     return VisitArraySpanInline<TimestampType>(

cpp/src/arrow/compute/kernels/scalar_temporal_binary.cc

@@ -44,17 +44,14 @@ 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;
 using arrow_vendored::date::year_month_day;
 using arrow_vendored::date::year_month_weekday;
 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;

cpp/src/arrow/compute/kernels/scalar_temporal_unary.cc

@@ -36,8 +36,7 @@ namespace arrow {
 using internal::checked_cast;
 using internal::checked_pointer_cast;
 
-namespace compute {
-namespace internal {
+namespace compute::internal {
 
 namespace {
 
@@ -60,7 +59,6 @@ using arrow_vendored::date::year;
 using arrow_vendored::date::year_month_day;
 using arrow_vendored::date::year_month_weekday;
 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;
@@ -664,15 +662,19 @@ struct Nanosecond {
 
 template <typename Duration>
 struct IsDaylightSavings {
-  explicit IsDaylightSavings(const FunctionOptions* options, const time_zone* tz)
+  explicit IsDaylightSavings(const FunctionOptions* options, const ArrowTimeZone tz)
       : tz_(tz) {}
 
   template <typename T, typename Arg0>
   T Call(KernelContext*, Arg0 arg, Status*) const {
-    return tz_->get_info(sys_time<Duration>{Duration{arg}}).save.count() != 0;
+    return std::visit(
+        [&arg](const auto& tz) -> bool {
+          return tz->get_info(sys_time<Duration>{Duration{arg}}).save.count() != 0;
+        },
+        tz_);
   }
 
-  const time_zone* tz_;
+  const ArrowTimeZone tz_;
 };
 
 // ----------------------------------------------------------------------
@@ -1166,7 +1168,7 @@ Result<std::locale> GetLocale(const std::string& locale) {
 template <typename Duration, typename InType>
 struct Strftime {
   const StrftimeOptions& options;
-  const time_zone* tz;
+  const ArrowTimeZone tz;
   const std::locale locale;
 
   static Result<Strftime> Make(KernelContext* ctx, const DataType& type) {
@@ -1187,9 +1189,7 @@ struct Strftime {
             options.format);
       }
     }
-
-    ARROW_ASSIGN_OR_RAISE(const time_zone* tz,
-                          LocateZone(timezone.empty() ? "UTC" : timezone));
+    ARROW_ASSIGN_OR_RAISE(auto tz, LocateZone(timezone.empty() ? "UTC" : timezone));
 
     ARROW_ASSIGN_OR_RAISE(std::locale locale, GetLocale(options.locale));
 
@@ -1354,31 +1354,31 @@ Result<TypeHolder> ResolveLocalTimestampOutput(KernelContext* ctx,
 
 template <typename Duration>
 struct AssumeTimezone {
-  explicit AssumeTimezone(const AssumeTimezoneOptions* options, const time_zone* tz)
+  explicit AssumeTimezone(const AssumeTimezoneOptions* options, const ArrowTimeZone 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());
+  T get_local_time(Arg0 arg, const ArrowTimeZone* tz) const {
+    const auto lt = local_time<Duration>(Duration{arg});
+    auto local_to_sys_time = [&](auto&& t) {
+      return t.get_sys_time().time_since_epoch().count();
+    };
+    return ApplyTimeZone(tz_, lt, std::nullopt, local_to_sys_time);
   }
 
   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());
+  T get_local_time(Arg0 arg, const choose c, const ArrowTimeZone* tz) const {
+    const auto lt = local_time<Duration>(Duration{arg});
+    auto local_to_sys_time = [&](auto&& t) {
+      return t.get_sys_time().time_since_epoch().count();
+    };
+    return ApplyTimeZone(tz_, lt, c, local_to_sys_time);
   }
 
   template <typename T, typename Arg0>
   T Call(KernelContext*, Arg0 arg, Status* st) const {
     try {
-      return get_local_time<T, Arg0>(arg, tz_);
+      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: {
@@ -1387,11 +1387,12 @@ struct AssumeTimezone {
           return arg;
         }
         case AssumeTimezoneOptions::Nonexistent::NONEXISTENT_EARLIEST: {
-          return get_local_time<T, Arg0>(arg, arrow_vendored::date::choose::latest, tz_) -
+          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_);
+          return get_local_time<T, Arg0>(arg, arrow_vendored::date::choose::latest, &tz_);
         }
       }
     } catch (const arrow_vendored::date::ambiguous_local_time& e) {
@@ -1403,17 +1404,17 @@ struct AssumeTimezone {
         }
         case AssumeTimezoneOptions::Ambiguous::AMBIGUOUS_EARLIEST: {
           return get_local_time<T, Arg0>(arg, arrow_vendored::date::choose::earliest,
-                                         tz_);
+                                         &tz_);
         }
         case AssumeTimezoneOptions::Ambiguous::AMBIGUOUS_LATEST: {
-          return get_local_time<T, Arg0>(arg, arrow_vendored::date::choose::latest, tz_);
+          return get_local_time<T, Arg0>(arg, arrow_vendored::date::choose::latest, &tz_);
         }
       }
     }
     return 0;
   }
   AssumeTimezoneOptions options;
-  const time_zone* tz_;
+  const ArrowTimeZone tz_;
 };
 
 // ----------------------------------------------------------------------
@@ -2035,6 +2036,5 @@ void RegisterScalarTemporalUnary(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(round_temporal)));
 }
 
-}  // namespace internal
-}  // namespace compute
+}  // namespace compute::internal
 }  // namespace arrow

cpp/src/arrow/compute/kernels/temporal_internal.cc

@@ -0,0 +1,55 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/compute/kernels/temporal_internal.h"
+
+namespace arrow::compute::internal {
+
+Result<ArrowTimeZone> LocateZone(const std::string_view timezone) {
+  if (timezone[0] == '+' || timezone[0] == '-') {
+    // Valid offset strings have to have 4 digits and a sign prefix.
+    // Valid examples: +01:23 and -0123.
+    // Invalid examples: 1:23, 123, 0123, 01:23, +25:00, -12:34:45, +090000.
+    auto offset = std::string(timezone.substr(1));
+    std::chrono::minutes zone_offset;
+    switch (timezone.length()) {
+      case 6:
+        if (arrow::internal::detail::ParseHH_MM(offset.c_str(), &zone_offset)) {
+          break;
+        }
+        [[fallthrough]];
+      case 5:
+        if (arrow::internal::detail::ParseHHMM(offset.c_str(), &zone_offset)) {
+          break;
+        }
+        [[fallthrough]];
+      default:
+        return Status::Invalid("Cannot locate or parse timezone '", timezone, "'");
+    }
+    zone_offset = timezone[0] == '-' ? -zone_offset : zone_offset;
+    return OffsetZone(zone_offset);
+  }
+
+  try {
+    return locate_zone(timezone);
+  } catch (const std::runtime_error& ex) {
+    return Status::Invalid("Cannot locate or parse timezone '", timezone,
+                           "': ", ex.what());
+  }
+}
+
+}  // namespace arrow::compute::internal