From 0e8f2faa6e08b33c2da2f056d36fe18fb0724562 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Sun, 27 Jun 2021 22:40:09 +0200
Subject: [PATCH 01/10] Add strftime kernel.

---
 cpp/src/arrow/compute/api_scalar.cc           | 17 ++++
 cpp/src/arrow/compute/api_scalar.h            | 27 +++++
 cpp/src/arrow/compute/function_test.cc        |  3 +
 .../arrow/compute/kernels/scalar_temporal.cc  | 99 +++++++++++++++++++
 .../compute/kernels/scalar_temporal_test.cc   | 23 +++++
 docs/source/cpp/compute.rst                   |  4 +
 python/pyarrow/_compute.pyx                   | 13 +++
 python/pyarrow/compute.py                     |  1 +
 python/pyarrow/includes/libarrow.pxd          |  4 +
 python/pyarrow/tests/test_compute.py          | 31 +++++-
 r/src/compute.cpp                             | 12 +++
 11 files changed, 233 insertions(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index f9c95a7745b..7a1a28f9e9c 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -145,6 +145,9 @@ static auto kSetLookupOptionsType = GetFunctionOptionsType<SetLookupOptions>(
 static auto kStrptimeOptionsType = GetFunctionOptionsType<StrptimeOptions>(
     DataMember("format", &StrptimeOptions::format),
     DataMember("unit", &StrptimeOptions::unit));
+static auto kStrftimeOptionsType = GetFunctionOptionsType<StrftimeOptions>(
+    DataMember("format", &StrftimeOptions::format),
+    DataMember("timezone", &StrftimeOptions::timezone));
 static auto kPadOptionsType = GetFunctionOptionsType<PadOptions>(
     DataMember("width", &PadOptions::width), DataMember("padding", &PadOptions::padding));
 static auto kTrimOptionsType = GetFunctionOptionsType<TrimOptions>(
@@ -238,6 +241,15 @@ StrptimeOptions::StrptimeOptions(std::string format, TimeUnit::type unit)
 StrptimeOptions::StrptimeOptions() : StrptimeOptions("", TimeUnit::SECOND) {}
 constexpr char StrptimeOptions::kTypeName[];
 
+StrftimeOptions::StrftimeOptions(std::string format, std::string timezone)
+    : FunctionOptions(internal::kStrftimeOptionsType),
+      format(std::move(format)),
+      timezone(std::move(timezone)) {
+  tz = arrow_vendored::date::locate_zone(this->timezone);
+}
+StrftimeOptions::StrftimeOptions() : StrftimeOptions("%Y-%m-%dT%H:%M:%S", "UTC") {}
+constexpr char StrftimeOptions::kTypeName[];
+
 PadOptions::PadOptions(int64_t width, std::string padding)
     : FunctionOptions(internal::kPadOptionsType),
       width(width),
@@ -294,6 +306,7 @@ void RegisterScalarOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kExtractRegexOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kSetLookupOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kStrptimeOptionsType));
+  DCHECK_OK(registry->AddFunctionOptionsType(kStrftimeOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kPadOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kTrimOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kSliceOptionsType));
@@ -495,5 +508,9 @@ Result<Datum> DayOfWeek(const Datum& arg, DayOfWeekOptions options, ExecContext*
   return CallFunction("day_of_week", {arg}, &options, ctx);
 }
 
+Result<Datum> Strftime(const Datum& arg, StrftimeOptions options, ExecContext* ctx) {
+  return CallFunction("strftime", {arg}, &options, ctx);
+}
+
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 115cad13d6f..5a053bff05a 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 {
@@ -178,6 +179,20 @@ class ARROW_EXPORT StrptimeOptions : public FunctionOptions {
   TimeUnit::type unit;
 };
 
+class ARROW_EXPORT StrftimeOptions : public FunctionOptions {
+ public:
+  explicit StrftimeOptions(std::string format, std::string timezone);
+  StrftimeOptions();
+  constexpr static char const kTypeName[] = "StrftimeOptions";
+
+  /// The desired format string.
+  std::string format;
+  /// Timezone to output the time in.
+  std::string timezone;
+  /// Timezone to output the time in.
+  const arrow_vendored::date::time_zone* tz;
+};
+
 class ARROW_EXPORT PadOptions : public FunctionOptions {
  public:
   explicit PadOptions(int64_t width, std::string padding = " ");
@@ -999,5 +1014,17 @@ Result<Datum> Nanosecond(const Datum& values, ExecContext* ctx = NULLPTR);
 /// \note API not yet finalized
 ARROW_EXPORT Result<Datum> Subsecond(const Datum& values, ExecContext* ctx = NULLPTR);
 
+/// \brief Strftime
+///
+/// \param[in] values input to print time string from
+/// \param[in] options for setting time format and timezone
+/// \param[in] ctx the function execution context, optional
+/// \return the resulting datum
+///
+/// \since 5.0.0
+/// \note API not yet finalized
+ARROW_EXPORT Result<Datum> Strftime(const Datum& values, StrftimeOptions 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 16d3affe720..7d344886886 100644
--- a/cpp/src/arrow/compute/function_test.cc
+++ b/cpp/src/arrow/compute/function_test.cc
@@ -79,6 +79,9 @@ TEST(FunctionOptions, Equality) {
   options.emplace_back(new SetLookupOptions(ArrayFromJSON(boolean(), "[true, false]")));
   options.emplace_back(new StrptimeOptions("%Y", TimeUnit::type::MILLI));
   options.emplace_back(new StrptimeOptions("%Y", TimeUnit::type::NANO));
+#ifndef _WIN32
+  options.emplace_back(new StrftimeOptions("%Y-%m-%dT%H:%M:%S", "UTC"));
+#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/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index b6cabddd118..c3ae720bbda 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -55,6 +55,7 @@ using internal::applicator::ScalarUnaryNotNull;
 using internal::applicator::SimpleUnary;
 
 using DayOfWeekState = OptionsWrapper<DayOfWeekOptions>;
+using StrftimeState = OptionsWrapper<StrftimeOptions>;
 
 const std::shared_ptr<DataType>& IsoCalendarType() {
   static auto type = struct_({field("iso_year", int64()), field("iso_week", int64()),
@@ -444,6 +445,53 @@ struct Nanosecond {
   }
 };
 
+// ----------------------------------------------------------------------
+// Convert timestamps to a string representation with an arbitrary format
+
+template <typename Duration>
+inline std::string get_timestamp(int64_t arg, const StrftimeOptions* options) {
+  auto zt = arrow_vendored::date::zoned_time<Duration>{options->tz,
+                                                       sys_time<Duration>(Duration{arg})};
+  return arrow_vendored::date::format(options->format, zt.get_local_time());
+}
+
+template <typename Duration>
+struct Strftime {
+  static Status Call(KernelContext* ctx, const Scalar& in, Scalar* out) {
+    const StrftimeOptions options = StrftimeState::Get(ctx);
+
+    if (in.is_valid) {
+      const auto& in_val = internal::UnboxScalar<const TimestampType>::Unbox(in);
+      *checked_cast<StringScalar*>(out) =
+          StringScalar(get_timestamp<Duration>(in_val, &options));
+    } else {
+      out->is_valid = false;
+    }
+    return Status::OK();
+  }
+
+  static Status Call(KernelContext* ctx, const ArrayData& in, ArrayData* out) {
+    const StrftimeOptions options = StrftimeState::Get(ctx);
+
+    std::unique_ptr<ArrayBuilder> array_builder;
+    RETURN_NOT_OK(MakeBuilder(ctx->memory_pool(), utf8(), &array_builder));
+    StringBuilder* string_builder = checked_cast<StringBuilder*>(array_builder.get());
+    RETURN_NOT_OK(string_builder->Reserve(in.length * 30));
+
+    auto visit_null = [&]() { return string_builder->AppendNull(); };
+    auto visit_value = [&](int64_t arg) {
+      return string_builder->Append(get_timestamp<Duration>(arg, &options));
+    };
+    RETURN_NOT_OK(VisitArrayDataInline<Int64Type>(in, visit_value, visit_null));
+
+    std::shared_ptr<Array> out_array;
+    RETURN_NOT_OK(string_builder->Finish(&out_array));
+    *out = *std::move(out_array->data());
+
+    return Status::OK();
+  }
+};
+
 // ----------------------------------------------------------------------
 // Extract ISO calendar values from timestamp
 
@@ -580,6 +628,41 @@ std::shared_ptr<ScalarFunction> MakeTemporal(
   return func;
 }
 
+std::shared_ptr<ScalarFunction> MakeStrftime(std::string name, const FunctionDoc* doc,
+                                             const StrftimeOptions& default_options,
+                                             KernelInit init) {
+  const auto& out_type = utf8();
+  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<Strftime<std::chrono::seconds>>;
+        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+        break;
+      }
+      case TimeUnit::MILLI: {
+        auto exec = SimpleUnary<Strftime<std::chrono::milliseconds>>;
+        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+        break;
+      }
+      case TimeUnit::MICRO: {
+        auto exec = SimpleUnary<Strftime<std::chrono::microseconds>>;
+        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+        break;
+      }
+      case TimeUnit::NANO: {
+        auto exec = SimpleUnary<Strftime<std::chrono::nanoseconds>>;
+        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+        break;
+      }
+    }
+  }
+  return func;
+}
+
 template <template <typename...> class Op>
 std::shared_ptr<ScalarFunction> MakeSimpleUnaryTemporal(
     std::string name, const std::shared_ptr<arrow::DataType> out_type,
@@ -713,6 +796,15 @@ const FunctionDoc subsecond_doc{
      "Returns an error if timestamp has a defined timezone. Null values return null."),
     {"values"}};
 
+const FunctionDoc strftime_doc{
+    "Convert timestamps to a string representation with an arbitrary format",
+    ("Strftime returns a string representation with an arbitrary format.\n"
+     "Returns an error if timestamp has a defined timezone.\n"
+     "The time format string and output timezone can be set"
+     "via options."),
+    {"values"},
+    "StrftimeOptions"};
+
 }  // namespace
 
 void RegisterScalarTemporal(FunctionRegistry* registry) {
@@ -782,6 +874,13 @@ void RegisterScalarTemporal(FunctionRegistry* registry) {
   auto subsecond = MakeTemporal<Subsecond, TemporalComponentExtract, DoubleType>(
       "subsecond", float64(), &subsecond_doc);
   DCHECK_OK(registry->AddFunction(std::move(subsecond)));
+
+#ifndef _WIN32
+  static auto default_strftime_options = StrftimeOptions();
+  auto strftime = MakeStrftime("strftime", &strftime_doc, default_strftime_options,
+                               StrftimeState::Init);
+  DCHECK_OK(registry->AddFunction(std::move(strftime)));
+#endif
 }
 
 }  // 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 fa00d985287..0906622fa15 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
@@ -382,5 +382,28 @@ TEST_F(ScalarTemporalTest, DayOfWeek) {
                 DayOfWeek(timestamps, DayOfWeekOptions(/*one_based_numbering=*/false,
                                                        /*week_start=*/8)));
 }
+
+#ifndef _WIN32
+TEST_F(ScalarTemporalTest, Strftime) {
+  auto options_seconds = StrftimeOptions("%Y-%m-%dT%H:%M:%S", "UTC");
+  auto options_milliseconds = StrftimeOptions("%Y-%m-%dT%H:%M:%S", "UTC");
+  auto options_microseconds = StrftimeOptions("%Y-%m-%dT%H:%M:%S", "UTC");
+  auto options_nanoseconds = StrftimeOptions("%Y-%m-%dT%H:%M:%S", "UTC");
+
+  const char* times_seconds = R"(["1970-01-01T00:00:59", null])";
+  const char* times_milliseconds = R"(["1970-01-01T00:00:59.123", null])";
+  const char* times_microseconds = R"(["1970-01-01T00:00:59.123456", null])";
+  const char* times_nanoseconds = R"(["1970-01-01T00:00:59.123456789", null])";
+
+  CheckScalarUnary("strftime", timestamp(TimeUnit::SECOND), times_seconds, utf8(),
+                   times_seconds, &options_seconds);
+  CheckScalarUnary("strftime", timestamp(TimeUnit::MILLI), times_milliseconds, utf8(),
+                   times_milliseconds, &options_milliseconds);
+  CheckScalarUnary("strftime", timestamp(TimeUnit::MICRO), times_microseconds, utf8(),
+                   times_microseconds, &options_microseconds);
+  CheckScalarUnary("strftime", timestamp(TimeUnit::NANO), times_nanoseconds, utf8(),
+                   times_nanoseconds, &options_nanoseconds);
+}
+#endif
 }  // namespace compute
 }  // namespace arrow
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 39bbbec3e16..2880fb3c2b6 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1120,6 +1120,8 @@ If the input timestamps have a non-empty timezone, localized timestamp component
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
 | subsecond          | Unary      | Timestamp         | Double        |                            |       |
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
+| strftime           | Unary      | Temporal          | String        | :struct:`StrftimeOptions`  | \(4)  |
++--------------------+------------+-------------------+---------------+----------------------------+-------+
 
 * \(1) Outputs the number of the day of the week. By default week begins on Monday
   represented by 0 and ends on Sunday represented by 6. :member:`DayOfWeekOptions::week_start` can be used to set
@@ -1129,6 +1131,8 @@ If the input timestamps have a non-empty timezone, localized timestamp component
   starts with the first ISO week.
   See `ISO 8601 week date definition`_ for more details.
 * \(3) Output is a ``{"iso_year": output type, "iso_week": output type, "iso_day_of_week":  output type}`` Struct.
+* \(4) Output is a timestamp string. To define timestamp format :member:`StrftimeOptions::format` can be used.
+  :member:`StrftimeOptions::timezone` states the timezone in which the timestamp string will be created.
 
 .. _ISO 8601 week date definition: https://en.wikipedia.org/wiki/ISO_week_date#First_week
 
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 2d82928f377..99f41ca303b 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -981,6 +981,19 @@ class StrptimeOptions(_StrptimeOptions):
         self._set_options(format, unit)
 
 
+cdef class _StrftimeOptions(FunctionOptions):
+    def _set_options(self, format, timezone):
+        self.wrapped.reset(
+            new CStrftimeOptions(
+                tobytes(format), tobytes(timezone))
+        )
+
+
+class StrftimeOptions(_StrftimeOptions):
+    def __init__(self, format, timezone):
+        self._set_options(format, timezone)
+
+
 cdef class _DayOfWeekOptions(FunctionOptions):
     def _set_options(self, one_based_numbering, week_start):
         self.wrapped.reset(
diff --git a/python/pyarrow/compute.py b/python/pyarrow/compute.py
index 10880c2974c..eea2328a49a 100644
--- a/python/pyarrow/compute.py
+++ b/python/pyarrow/compute.py
@@ -53,6 +53,7 @@
     SplitOptions,
     SplitPatternOptions,
     StrptimeOptions,
+    StrftimeOptions,
     DayOfWeekOptions,
     TakeOptions,
     TDigestOptions,
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index 9260cd28f85..92bf182ac49 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -1951,6 +1951,10 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
             "arrow::compute::StrptimeOptions"(CFunctionOptions):
         CStrptimeOptions(c_string format, TimeUnit unit)
 
+    cdef cppclass CStrftimeOptions \
+            "arrow::compute::StrftimeOptions"(CFunctionOptions):
+        CStrftimeOptions(c_string format, c_string timezone)
+
     cdef cppclass CDayOfWeekOptions \
             "arrow::compute::DayOfWeekOptions"(CFunctionOptions):
         CDayOfWeekOptions(c_bool one_based_numbering, uint32_t week_start)
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 26d1f0e647c..62d19e8b5a7 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -130,9 +130,12 @@ def test_option_class_equality():
         pc.StrptimeOptions("%Y", "s"),
         pc.TrimOptions(" "),
     ]
+    if sys.platform != 'win32':
+        options.append(pc.StrftimeOptions("%Y", "UTC"))
     classes = {type(option) for option in options}
     for cls in exported_option_classes:
-        if cls not in classes:
+        if cls not in classes and sys.platform != 'win32' and \
+                cls != pc.StrftimeOptions:
             try:
                 options.append(cls())
             except TypeError:
@@ -1363,6 +1366,32 @@ def test_strptime():
     assert got == expected
 
 
+# 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_strftime():
+    ts = pd.date_range(pd.Timestamp("2018-03-10 09:00"), periods=3, freq="s")
+    timezones = ["CET", "UTC", "Europe/Ljubljana"]
+    formats = ["%Y", "%M", "%F", "%Y-%m-%d %H:%M", "%B %d, %Y, %r"]
+
+    for timezone in timezones:
+        for unit in ["s", "ms", "us", "ns"]:
+            tsa = pa.array(ts, type=pa.timestamp(unit, timezone))
+            for fmt in formats:
+                options = pc.StrftimeOptions(fmt, timezone)
+                result = pc.strftime(tsa, options=options)
+
+                expected = pa.array(ts.tz_localize(
+                    "UTC").tz_convert(timezone).strftime(fmt))
+                assert result.equals(expected)
+
+    tsa = pa.array(ts, type=pa.timestamp("s", "UTC"))
+    result = pc.strftime(tsa)
+    expected = pa.array(ts.strftime("%Y-%m-%dT%H:%M:%S"))
+    assert result.equals(expected)
+
+
 def _check_datetime_components(timestamps, timezone=None):
     from pyarrow.vendored.version import Version
 
diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index 0695e2525f7..1f015d7f641 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -296,6 +296,18 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
         cpp11::as_cpp<arrow::TimeUnit::type>(options["unit"]));
   }
 
+  if (func_name == "strftime") {
+    using Options = arrow::compute::StrftimeOptions;
+    auto out = std::make_shared<Options>(Options());
+    if (!Rf_isNull(options["format"])) {
+      out->format = cpp11::as_cpp<std::string>(options["format"]);
+    }
+    if (!Rf_isNull(options["timezone"])) {
+      out->timezone = cpp11::as_cpp<std::string>(options["timezone"]);
+    }
+    return out;
+  }
+
   if (func_name == "split_pattern" || func_name == "split_pattern_regex") {
     using Options = arrow::compute::SplitPatternOptions;
     int64_t max_splits = -1;

From 1679aa68fdbbaa39e33943279c46edf29d149167 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Tue, 13 Jul 2021 11:53:22 +0200
Subject: [PATCH 02/10] Review feedback.

---
 cpp/src/arrow/compute/api_scalar.cc           | 13 ++---
 cpp/src/arrow/compute/api_scalar.h            |  6 +-
 cpp/src/arrow/compute/function_test.cc        |  2 +-
 .../arrow/compute/kernels/scalar_temporal.cc  | 33 +++++++----
 .../compute/kernels/scalar_temporal_test.cc   | 42 ++++++++------
 docs/source/cpp/compute.rst                   |  1 -
 python/pyarrow/_compute.pyx                   | 11 ++--
 python/pyarrow/includes/libarrow.pxd          |  2 +-
 python/pyarrow/tests/test_compute.py          | 55 +++++++++++++++----
 r/configure.win                               |  2 +-
 r/src/compute.cpp                             |  3 -
 11 files changed, 105 insertions(+), 65 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index 7a1a28f9e9c..c1e8ee31baa 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -146,8 +146,7 @@ static auto kStrptimeOptionsType = GetFunctionOptionsType<StrptimeOptions>(
     DataMember("format", &StrptimeOptions::format),
     DataMember("unit", &StrptimeOptions::unit));
 static auto kStrftimeOptionsType = GetFunctionOptionsType<StrftimeOptions>(
-    DataMember("format", &StrftimeOptions::format),
-    DataMember("timezone", &StrftimeOptions::timezone));
+    DataMember("format", &StrftimeOptions::format));
 static auto kPadOptionsType = GetFunctionOptionsType<PadOptions>(
     DataMember("width", &PadOptions::width), DataMember("padding", &PadOptions::padding));
 static auto kTrimOptionsType = GetFunctionOptionsType<TrimOptions>(
@@ -241,13 +240,9 @@ StrptimeOptions::StrptimeOptions(std::string format, TimeUnit::type unit)
 StrptimeOptions::StrptimeOptions() : StrptimeOptions("", TimeUnit::SECOND) {}
 constexpr char StrptimeOptions::kTypeName[];
 
-StrftimeOptions::StrftimeOptions(std::string format, std::string timezone)
-    : FunctionOptions(internal::kStrftimeOptionsType),
-      format(std::move(format)),
-      timezone(std::move(timezone)) {
-  tz = arrow_vendored::date::locate_zone(this->timezone);
-}
-StrftimeOptions::StrftimeOptions() : StrftimeOptions("%Y-%m-%dT%H:%M:%S", "UTC") {}
+StrftimeOptions::StrftimeOptions(std::string format)
+    : FunctionOptions(internal::kStrftimeOptionsType), format(std::move(format)) {}
+StrftimeOptions::StrftimeOptions() : StrftimeOptions("%Y-%m-%dT%H:%M:%SZ") {}
 constexpr char StrftimeOptions::kTypeName[];
 
 PadOptions::PadOptions(int64_t width, std::string padding)
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 5a053bff05a..5966fad824c 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -181,16 +181,12 @@ class ARROW_EXPORT StrptimeOptions : public FunctionOptions {
 
 class ARROW_EXPORT StrftimeOptions : public FunctionOptions {
  public:
-  explicit StrftimeOptions(std::string format, std::string timezone);
+  explicit StrftimeOptions(std::string format);
   StrftimeOptions();
   constexpr static char const kTypeName[] = "StrftimeOptions";
 
   /// The desired format string.
   std::string format;
-  /// Timezone to output the time in.
-  std::string timezone;
-  /// Timezone to output the time in.
-  const arrow_vendored::date::time_zone* tz;
 };
 
 class ARROW_EXPORT PadOptions : public FunctionOptions {
diff --git a/cpp/src/arrow/compute/function_test.cc b/cpp/src/arrow/compute/function_test.cc
index 7d344886886..728ad3e2f79 100644
--- a/cpp/src/arrow/compute/function_test.cc
+++ b/cpp/src/arrow/compute/function_test.cc
@@ -80,7 +80,7 @@ TEST(FunctionOptions, Equality) {
   options.emplace_back(new StrptimeOptions("%Y", TimeUnit::type::MILLI));
   options.emplace_back(new StrptimeOptions("%Y", TimeUnit::type::NANO));
 #ifndef _WIN32
-  options.emplace_back(new StrftimeOptions("%Y-%m-%dT%H:%M:%S", "UTC"));
+  options.emplace_back(new StrftimeOptions("%Y-%m-%dT%H:%M:%SZ"));
 #endif
   options.emplace_back(new PadOptions(5, " "));
   options.emplace_back(new PadOptions(10, "A"));
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index c3ae720bbda..8e67d65d218 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -449,21 +449,28 @@ struct Nanosecond {
 // Convert timestamps to a string representation with an arbitrary format
 
 template <typename Duration>
-inline std::string get_timestamp(int64_t arg, const StrftimeOptions* options) {
-  auto zt = arrow_vendored::date::zoned_time<Duration>{options->tz,
-                                                       sys_time<Duration>(Duration{arg})};
-  return arrow_vendored::date::format(options->format, zt.get_local_time());
+inline std::string get_timestamp(int64_t arg, const time_zone* tz,
+                                 const std::string* format) {
+  auto zt =
+      arrow_vendored::date::zoned_time<Duration>{tz, sys_time<Duration>(Duration{arg})};
+  return arrow_vendored::date::format(*format, zt);
 }
 
 template <typename Duration>
 struct Strftime {
   static Status Call(KernelContext* ctx, const Scalar& in, Scalar* out) {
+    const auto& timezone = GetInputTimezone(in);
+    if (timezone.empty()) {
+      return Status::Invalid("Timezone naive timestamp can not be reliably printed.");
+    }
+    const arrow_vendored::date::time_zone* tz =
+        arrow_vendored::date::locate_zone(timezone);
     const StrftimeOptions options = StrftimeState::Get(ctx);
 
     if (in.is_valid) {
       const auto& in_val = internal::UnboxScalar<const TimestampType>::Unbox(in);
       *checked_cast<StringScalar*>(out) =
-          StringScalar(get_timestamp<Duration>(in_val, &options));
+          StringScalar(get_timestamp<Duration>(in_val, tz, &options.format));
     } else {
       out->is_valid = false;
     }
@@ -471,16 +478,24 @@ struct Strftime {
   }
 
   static Status Call(KernelContext* ctx, const ArrayData& in, ArrayData* out) {
+    const auto& timezone = GetInputTimezone(in);
+    if (timezone.empty()) {
+      return Status::Invalid("Timezone naive timestamp can not be reliably printed.");
+    }
+    const arrow_vendored::date::time_zone* tz =
+        arrow_vendored::date::locate_zone(timezone);
     const StrftimeOptions options = StrftimeState::Get(ctx);
 
     std::unique_ptr<ArrayBuilder> array_builder;
     RETURN_NOT_OK(MakeBuilder(ctx->memory_pool(), utf8(), &array_builder));
     StringBuilder* string_builder = checked_cast<StringBuilder*>(array_builder.get());
-    RETURN_NOT_OK(string_builder->Reserve(in.length * 30));
+    auto expected_string_size = static_cast<int64_t>(
+        ceil(get_timestamp<Duration>(0, tz, &options.format).size() * 1.1));
+    RETURN_NOT_OK(string_builder->Reserve(in.length * expected_string_size));
 
     auto visit_null = [&]() { return string_builder->AppendNull(); };
     auto visit_value = [&](int64_t arg) {
-      return string_builder->Append(get_timestamp<Duration>(arg, &options));
+      return string_builder->Append(get_timestamp<Duration>(arg, tz, &options.format));
     };
     RETURN_NOT_OK(VisitArrayDataInline<Int64Type>(in, visit_value, visit_null));
 
@@ -799,9 +814,7 @@ const FunctionDoc subsecond_doc{
 const FunctionDoc strftime_doc{
     "Convert timestamps to a string representation with an arbitrary format",
     ("Strftime returns a string representation with an arbitrary format.\n"
-     "Returns an error if timestamp has a defined timezone.\n"
-     "The time format string and output timezone can be set"
-     "via options."),
+     "The time format string can be set via options."),
     {"values"},
     "StrftimeOptions"};
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
index 0906622fa15..0eab9932fe1 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
@@ -385,24 +385,34 @@ TEST_F(ScalarTemporalTest, DayOfWeek) {
 
 #ifndef _WIN32
 TEST_F(ScalarTemporalTest, Strftime) {
-  auto options_seconds = StrftimeOptions("%Y-%m-%dT%H:%M:%S", "UTC");
-  auto options_milliseconds = StrftimeOptions("%Y-%m-%dT%H:%M:%S", "UTC");
-  auto options_microseconds = StrftimeOptions("%Y-%m-%dT%H:%M:%S", "UTC");
-  auto options_nanoseconds = StrftimeOptions("%Y-%m-%dT%H:%M:%S", "UTC");
+  auto options_default = StrftimeOptions();
+  auto options = StrftimeOptions("%Y-%m-%dT%H:%M:%S%z");
 
-  const char* times_seconds = R"(["1970-01-01T00:00:59", null])";
-  const char* times_milliseconds = R"(["1970-01-01T00:00:59.123", null])";
-  const char* times_microseconds = R"(["1970-01-01T00:00:59.123456", null])";
-  const char* times_nanoseconds = R"(["1970-01-01T00:00:59.123456789", null])";
+  const char* seconds = R"(["1970-01-01T00:00:59", null])";
+  const char* milliseconds = R"(["1970-01-01T00:00:59.123", null])";
+  const char* microseconds = R"(["1970-01-01T00:00:59.123456", null])";
+  const char* nanoseconds = R"(["1970-01-01T00:00:59.123456789", null])";
 
-  CheckScalarUnary("strftime", timestamp(TimeUnit::SECOND), times_seconds, utf8(),
-                   times_seconds, &options_seconds);
-  CheckScalarUnary("strftime", timestamp(TimeUnit::MILLI), times_milliseconds, utf8(),
-                   times_milliseconds, &options_milliseconds);
-  CheckScalarUnary("strftime", timestamp(TimeUnit::MICRO), times_microseconds, utf8(),
-                   times_microseconds, &options_microseconds);
-  CheckScalarUnary("strftime", timestamp(TimeUnit::NANO), times_nanoseconds, utf8(),
-                   times_nanoseconds, &options_nanoseconds);
+  const char* default_seconds = R"(["1970-01-01T00:00:59Z", null])";
+  const char* string_seconds = R"(["1970-01-01T00:00:59+0000", null])";
+  const char* string_milliseconds = R"(["1970-01-01T00:00:59.123+0000", null])";
+  const char* string_microseconds = R"(["1970-01-01T05:30:59.123456+0530", null])";
+  const char* string_nanoseconds = R"(["1969-12-31T14:00:59.123456789-1000", null])";
+
+  CheckScalarUnary("strftime", timestamp(TimeUnit::SECOND, "UTC"), seconds, utf8(),
+                   default_seconds, &options_default);
+  CheckScalarUnary("strftime", timestamp(TimeUnit::SECOND, "UTC"), seconds, utf8(),
+                   string_seconds, &options);
+  CheckScalarUnary("strftime", timestamp(TimeUnit::MILLI, "GMT"), milliseconds, utf8(),
+                   string_milliseconds, &options);
+  CheckScalarUnary("strftime", timestamp(TimeUnit::MICRO, "Asia/Kolkata"), microseconds,
+                   utf8(), string_microseconds, &options);
+  CheckScalarUnary("strftime", timestamp(TimeUnit::NANO, "US/Hawaii"), nanoseconds,
+                   utf8(), string_nanoseconds, &options);
+
+  auto naive_times = ArrayFromJSON(timestamp(TimeUnit::SECOND), seconds);
+  ASSERT_RAISES(Invalid, Strftime(naive_times, options_default));
+  ASSERT_RAISES(Invalid, Strftime(naive_times, options));
 }
 #endif
 }  // namespace compute
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 2880fb3c2b6..f29e2e5c6fa 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1132,7 +1132,6 @@ If the input timestamps have a non-empty timezone, localized timestamp component
   See `ISO 8601 week date definition`_ for more details.
 * \(3) Output is a ``{"iso_year": output type, "iso_week": output type, "iso_day_of_week":  output type}`` Struct.
 * \(4) Output is a timestamp string. To define timestamp format :member:`StrftimeOptions::format` can be used.
-  :member:`StrftimeOptions::timezone` states the timezone in which the timestamp string will be created.
 
 .. _ISO 8601 week date definition: https://en.wikipedia.org/wiki/ISO_week_date#First_week
 
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 99f41ca303b..d55dda2b230 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -982,16 +982,13 @@ class StrptimeOptions(_StrptimeOptions):
 
 
 cdef class _StrftimeOptions(FunctionOptions):
-    def _set_options(self, format, timezone):
-        self.wrapped.reset(
-            new CStrftimeOptions(
-                tobytes(format), tobytes(timezone))
-        )
+    def _set_options(self, format):
+        self.wrapped.reset(new CStrftimeOptions(tobytes(format)))
 
 
 class StrftimeOptions(_StrftimeOptions):
-    def __init__(self, format, timezone):
-        self._set_options(format, timezone)
+    def __init__(self, format="%Y-%m-%dT%H:%M:%SZ"):
+        self._set_options(format)
 
 
 cdef class _DayOfWeekOptions(FunctionOptions):
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index 92bf182ac49..8342c2b8fec 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -1953,7 +1953,7 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
 
     cdef cppclass CStrftimeOptions \
             "arrow::compute::StrftimeOptions"(CFunctionOptions):
-        CStrftimeOptions(c_string format, c_string timezone)
+        CStrftimeOptions(c_string format)
 
     cdef cppclass CDayOfWeekOptions \
             "arrow::compute::DayOfWeekOptions"(CFunctionOptions):
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 62d19e8b5a7..ad32f2a3164 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -131,7 +131,7 @@ def test_option_class_equality():
         pc.TrimOptions(" "),
     ]
     if sys.platform != 'win32':
-        options.append(pc.StrftimeOptions("%Y", "UTC"))
+        options.append(pc.StrftimeOptions())
     classes = {type(option) for option in options}
     for cls in exported_option_classes:
         if cls not in classes and sys.platform != 'win32' and \
@@ -1371,25 +1371,58 @@ def test_strptime():
 @pytest.mark.skipif(sys.platform == 'win32',
                     reason="Timezone database is not available on Windows yet")
 def test_strftime():
-    ts = pd.date_range(pd.Timestamp("2018-03-10 09:00"), periods=3, freq="s")
+    from pyarrow.vendored.version import Version
+
+    def _fix_timestamp(s):
+        if Version(pd.__version__) <= Version("0.23.0"):
+            return s.to_series().replace("NaT", pd.NaT)
+        else:
+            return s
+
+    times = ["2018-03-10 09:00", "2038-01-31 12:23", None]
     timezones = ["CET", "UTC", "Europe/Ljubljana"]
-    formats = ["%Y", "%M", "%F", "%Y-%m-%d %H:%M", "%B %d, %Y, %r"]
+
+    formats = ["%a", "%A", "%w", "%d", "%b", "%B", "%m", "%y", "%Y", "%H",
+               "%I", "%p", "%M", "%z", "%Z", "%j", "%U", "%W", "%c", "%x",
+               "%X", "%%", "%G", "%V", "%u", "%V"]
 
     for timezone in timezones:
+        ts = pd.to_datetime(times).tz_localize(timezone)
         for unit in ["s", "ms", "us", "ns"]:
             tsa = pa.array(ts, type=pa.timestamp(unit, timezone))
             for fmt in formats:
-                options = pc.StrftimeOptions(fmt, timezone)
+                options = pc.StrftimeOptions(fmt)
                 result = pc.strftime(tsa, options=options)
-
-                expected = pa.array(ts.tz_localize(
-                    "UTC").tz_convert(timezone).strftime(fmt))
+                expected = pa.array(_fix_timestamp(ts.strftime(fmt)))
                 assert result.equals(expected)
 
-    tsa = pa.array(ts, type=pa.timestamp("s", "UTC"))
-    result = pc.strftime(tsa)
-    expected = pa.array(ts.strftime("%Y-%m-%dT%H:%M:%S"))
-    assert result.equals(expected)
+        # Default format
+        tsa = pa.array(ts, type=pa.timestamp("s", timezone))
+        result = pc.strftime(tsa, options=pc.StrftimeOptions())
+        expected = pa.array(_fix_timestamp(ts.strftime("%Y-%m-%dT%H:%M:%SZ")))
+        assert result.equals(expected)
+
+        # Pandas %S is equivalent to %S in arrow for unit="s"
+        tsa = pa.array(ts, type=pa.timestamp("s", timezone))
+        options = pc.StrftimeOptions("%S")
+        result = pc.strftime(tsa, options=options)
+        expected = pa.array(_fix_timestamp(ts.strftime("%S")))
+        assert result.equals(expected)
+
+        # Pandas %S.%f is equivalent to %S in arrow for unit="us"
+        tsa = pa.array(ts, type=pa.timestamp("us", timezone))
+        options = pc.StrftimeOptions("%S")
+        result = pc.strftime(tsa, options=options)
+        expected = pa.array(_fix_timestamp(ts.strftime("%S.%f")))
+        assert result.equals(expected)
+
+    for unit in ["s", "ms", "us", "ns"]:
+        tsa = pa.array(ts, type=pa.timestamp(unit))
+        for fmt in formats:
+            with pytest.raises(pa.ArrowInvalid, match="Timezone naive "
+                                                      "timestamp can not be "
+                                                      "reliably printed."):
+                pc.strftime(tsa, options=pc.StrftimeOptions(fmt))
 
 
 def _check_datetime_components(timestamps, timezone=None):
diff --git a/r/configure.win b/r/configure.win
index d830a238c39..ce68a41b353 100644
--- a/r/configure.win
+++ b/r/configure.win
@@ -44,7 +44,7 @@ else
   RWINLIB="../windows/$(ls windows/ | grep ^arrow- | tail -n 1)"
 fi
 OPENSSL_LIBS="-lcrypto -lcrypt32"
-MIMALLOC_LIBS="-lbcrypt -lpsapi"
+MIMALLOC_LIBS="-lbcrypt -lpsapi -lole32"
 AWS_LIBS="-laws-cpp-sdk-config -laws-cpp-sdk-transfer -laws-cpp-sdk-identity-management -laws-cpp-sdk-cognito-identity -laws-cpp-sdk-sts -laws-cpp-sdk-s3 -laws-cpp-sdk-core -laws-c-event-stream -laws-checksums -laws-c-common -lUserenv -lversion -lws2_32 -lBcrypt -lWininet -lwinhttp"
 
 # NOTE: If you make changes to the libraries below, you should also change
diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index 1f015d7f641..b33dec0f27d 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -302,9 +302,6 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
     if (!Rf_isNull(options["format"])) {
       out->format = cpp11::as_cpp<std::string>(options["format"]);
     }
-    if (!Rf_isNull(options["timezone"])) {
-      out->timezone = cpp11::as_cpp<std::string>(options["timezone"]);
-    }
     return out;
   }
 

From 3ed11c628d77c5e2862cc895d92c5dd6b98cc987 Mon Sep 17 00:00:00 2001
From: Rok Mihevc <rok@mihevc.org>
Date: Fri, 16 Jul 2021 21:54:48 +0200
Subject: [PATCH 03/10] Apply suggestions from code review

Co-authored-by: Weston Pace <weston.pace@gmail.com>
---
 cpp/src/arrow/compute/api_scalar.h               | 2 +-
 cpp/src/arrow/compute/kernels/scalar_temporal.cc | 5 +++--
 python/pyarrow/tests/test_compute.py             | 4 ++--
 3 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 5966fad824c..c137a4224c8 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -1013,7 +1013,7 @@ ARROW_EXPORT Result<Datum> Subsecond(const Datum& values, ExecContext* ctx = NUL
 /// \brief Strftime
 ///
 /// \param[in] values input to print time string from
-/// \param[in] options for setting time format and timezone
+/// \param[in] options for setting time format
 /// \param[in] ctx the function execution context, optional
 /// \return the resulting datum
 ///
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index 8e67d65d218..2804127e795 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -461,7 +461,8 @@ struct Strftime {
   static Status Call(KernelContext* ctx, const Scalar& in, Scalar* out) {
     const auto& timezone = GetInputTimezone(in);
     if (timezone.empty()) {
-      return Status::Invalid("Timezone naive timestamp can not be reliably printed.");
+      return Status::Invalid(
+          "Timestamps without a time zone cannot be reliably printed.");
     }
     const arrow_vendored::date::time_zone* tz =
         arrow_vendored::date::locate_zone(timezone);
@@ -480,7 +481,7 @@ struct Strftime {
   static Status Call(KernelContext* ctx, const ArrayData& in, ArrayData* out) {
     const auto& timezone = GetInputTimezone(in);
     if (timezone.empty()) {
-      return Status::Invalid("Timezone naive timestamp can not be reliably printed.");
+      return Status::Invalid("Timestamp without a time zone cannot be reliably printed.");
     }
     const arrow_vendored::date::time_zone* tz =
         arrow_vendored::date::locate_zone(timezone);
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index ad32f2a3164..3d62757a919 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -1419,8 +1419,8 @@ def _fix_timestamp(s):
     for unit in ["s", "ms", "us", "ns"]:
         tsa = pa.array(ts, type=pa.timestamp(unit))
         for fmt in formats:
-            with pytest.raises(pa.ArrowInvalid, match="Timezone naive "
-                                                      "timestamp can not be "
+            with pytest.raises(pa.ArrowInvalid, match="Timestamp without a "
+                                                      "time zone cannot be "
                                                       "reliably printed."):
                 pc.strftime(tsa, options=pc.StrftimeOptions(fmt))
 

From d44625b2dac89788dc47193c292f5eb27bf31633 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Tue, 20 Jul 2021 16:16:30 +0200
Subject: [PATCH 04/10] Adding locale option.

---
 cpp/src/arrow/compute/api_scalar.cc           |  8 +++-
 cpp/src/arrow/compute/api_scalar.h            |  3 ++
 cpp/src/arrow/compute/function_test.cc        |  4 +-
 .../arrow/compute/kernels/scalar_temporal.cc  | 15 ++++----
 .../compute/kernels/scalar_temporal_test.cc   | 37 +++++++++++++++++++
 python/pyarrow/_compute.pyx                   | 10 +++--
 python/pyarrow/includes/libarrow.pxd          |  2 +-
 python/pyarrow/tests/test_compute.py          |  7 ++++
 r/src/compute.cpp                             | 10 +++--
 9 files changed, 77 insertions(+), 19 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index c1e8ee31baa..d9eb4b94978 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -240,8 +240,14 @@ StrptimeOptions::StrptimeOptions(std::string format, TimeUnit::type unit)
 StrptimeOptions::StrptimeOptions() : StrptimeOptions("", TimeUnit::SECOND) {}
 constexpr char StrptimeOptions::kTypeName[];
 
+StrftimeOptions::StrftimeOptions(std::string format, std::string locale)
+    : FunctionOptions(internal::kStrftimeOptionsType), format(std::move(format)) {
+  loc = std::locale(locale);
+}
 StrftimeOptions::StrftimeOptions(std::string format)
-    : FunctionOptions(internal::kStrftimeOptionsType), format(std::move(format)) {}
+    : FunctionOptions(internal::kStrftimeOptionsType), format(std::move(format)) {
+  loc = std::locale("C");
+}
 StrftimeOptions::StrftimeOptions() : StrftimeOptions("%Y-%m-%dT%H:%M:%SZ") {}
 constexpr char StrftimeOptions::kTypeName[];
 
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index c137a4224c8..aa9359eae48 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -181,12 +181,15 @@ class ARROW_EXPORT StrptimeOptions : public FunctionOptions {
 
 class ARROW_EXPORT StrftimeOptions : public FunctionOptions {
  public:
+  explicit StrftimeOptions(std::string format, std::string locale);
   explicit StrftimeOptions(std::string format);
   StrftimeOptions();
   constexpr static char const kTypeName[] = "StrftimeOptions";
 
   /// The desired format string.
   std::string format;
+  /// The desired output locale.
+  std::locale loc;
 };
 
 class ARROW_EXPORT PadOptions : public FunctionOptions {
diff --git a/cpp/src/arrow/compute/function_test.cc b/cpp/src/arrow/compute/function_test.cc
index 728ad3e2f79..d7ebdf3de1d 100644
--- a/cpp/src/arrow/compute/function_test.cc
+++ b/cpp/src/arrow/compute/function_test.cc
@@ -79,9 +79,7 @@ TEST(FunctionOptions, Equality) {
   options.emplace_back(new SetLookupOptions(ArrayFromJSON(boolean(), "[true, false]")));
   options.emplace_back(new StrptimeOptions("%Y", TimeUnit::type::MILLI));
   options.emplace_back(new StrptimeOptions("%Y", TimeUnit::type::NANO));
-#ifndef _WIN32
-  options.emplace_back(new StrftimeOptions("%Y-%m-%dT%H:%M:%SZ"));
-#endif
+  options.emplace_back(new StrftimeOptions("%Y-%m-%dT%H:%M:%SZ", "C"));
   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/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index 2804127e795..43391270b49 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -449,11 +449,11 @@ struct Nanosecond {
 // Convert timestamps to a string representation with an arbitrary format
 
 template <typename Duration>
-inline std::string get_timestamp(int64_t arg, const time_zone* tz,
-                                 const std::string* format) {
+inline std::string get_timestamp(int64_t arg, const std::locale* locale,
+                                 const time_zone* tz, const std::string* format) {
   auto zt =
       arrow_vendored::date::zoned_time<Duration>{tz, sys_time<Duration>(Duration{arg})};
-  return arrow_vendored::date::format(*format, zt);
+  return arrow_vendored::date::format(*locale, *format, zt);
 }
 
 template <typename Duration>
@@ -470,8 +470,8 @@ struct Strftime {
 
     if (in.is_valid) {
       const auto& in_val = internal::UnboxScalar<const TimestampType>::Unbox(in);
-      *checked_cast<StringScalar*>(out) =
-          StringScalar(get_timestamp<Duration>(in_val, tz, &options.format));
+      *checked_cast<StringScalar*>(out) = StringScalar(
+          get_timestamp<Duration>(in_val, &options.loc, tz, &options.format));
     } else {
       out->is_valid = false;
     }
@@ -491,12 +491,13 @@ struct Strftime {
     RETURN_NOT_OK(MakeBuilder(ctx->memory_pool(), utf8(), &array_builder));
     StringBuilder* string_builder = checked_cast<StringBuilder*>(array_builder.get());
     auto expected_string_size = static_cast<int64_t>(
-        ceil(get_timestamp<Duration>(0, tz, &options.format).size() * 1.1));
+        ceil(get_timestamp<Duration>(0, &options.loc, tz, &options.format).size() * 1.1));
     RETURN_NOT_OK(string_builder->Reserve(in.length * expected_string_size));
 
     auto visit_null = [&]() { return string_builder->AppendNull(); };
     auto visit_value = [&](int64_t arg) {
-      return string_builder->Append(get_timestamp<Duration>(arg, tz, &options.format));
+      return string_builder->Append(
+          get_timestamp<Duration>(arg, &options.loc, tz, &options.format));
     };
     RETURN_NOT_OK(VisitArrayDataInline<Int64Type>(in, visit_value, visit_null));
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
index 0eab9932fe1..c29ac9522e1 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
@@ -414,6 +414,43 @@ TEST_F(ScalarTemporalTest, Strftime) {
   ASSERT_RAISES(Invalid, Strftime(naive_times, options_default));
   ASSERT_RAISES(Invalid, Strftime(naive_times, options));
 }
+
+TEST_F(ScalarTemporalTest, StrftimeWithLocale) {
+  auto options_default = StrftimeOptions();
+  auto options = StrftimeOptions("%Y-%m-%dT%H:%M:%S%z", "C");
+  auto options_locale_specific = StrftimeOptions("%a", "C");
+
+  const char* seconds = R"(["1970-01-01T00:00:59", null])";
+  const char* milliseconds = R"(["1970-01-01T00:00:59.123", null])";
+  const char* microseconds = R"(["1970-01-01T00:00:59.123456", null])";
+  const char* nanoseconds = R"(["1970-01-01T00:00:59.123456789", null])";
+
+  const char* default_seconds = R"(["1970-01-01T00:00:59Z", null])";
+  const char* string_seconds = R"(["1970-01-01T00:00:59+0000", null])";
+  const char* string_milliseconds = R"(["1970-01-01T00:00:59.123+0000", null])";
+  const char* string_microseconds = R"(["1970-01-01T05:30:59.123456+0530", null])";
+  const char* string_nanoseconds = R"(["1969-12-31T14:00:59.123456789-1000", null])";
+
+  const char* string_locale_specific = R"(["Wed", null])";
+
+  CheckScalarUnary("strftime", timestamp(TimeUnit::SECOND, "UTC"), seconds, utf8(),
+                   default_seconds, &options_default);
+  CheckScalarUnary("strftime", timestamp(TimeUnit::SECOND, "UTC"), seconds, utf8(),
+                   string_seconds, &options);
+  CheckScalarUnary("strftime", timestamp(TimeUnit::MILLI, "GMT"), milliseconds, utf8(),
+                   string_milliseconds, &options);
+  CheckScalarUnary("strftime", timestamp(TimeUnit::MICRO, "Asia/Kolkata"), microseconds,
+                   utf8(), string_microseconds, &options);
+  CheckScalarUnary("strftime", timestamp(TimeUnit::NANO, "US/Hawaii"), nanoseconds,
+                   utf8(), string_nanoseconds, &options);
+
+  CheckScalarUnary("strftime", timestamp(TimeUnit::NANO, "US/Hawaii"), nanoseconds,
+                   utf8(), string_locale_specific, &options_locale_specific);
+
+  auto naive_times = ArrayFromJSON(timestamp(TimeUnit::SECOND), seconds);
+  ASSERT_RAISES(Invalid, Strftime(naive_times, options_default));
+  ASSERT_RAISES(Invalid, Strftime(naive_times, options));
+}
 #endif
 }  // namespace compute
 }  // namespace arrow
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index d55dda2b230..35a4ff696db 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -982,13 +982,15 @@ class StrptimeOptions(_StrptimeOptions):
 
 
 cdef class _StrftimeOptions(FunctionOptions):
-    def _set_options(self, format):
-        self.wrapped.reset(new CStrftimeOptions(tobytes(format)))
+    def _set_options(self, format, locale):
+        self.wrapped.reset(
+            new CStrftimeOptions(tobytes(format), tobytes(locale))
+        )
 
 
 class StrftimeOptions(_StrftimeOptions):
-    def __init__(self, format="%Y-%m-%dT%H:%M:%SZ"):
-        self._set_options(format)
+    def __init__(self, format="%Y-%m-%dT%H:%M:%SZ", locale="C"):
+        self._set_options(format, locale)
 
 
 cdef class _DayOfWeekOptions(FunctionOptions):
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index 8342c2b8fec..025eeef18af 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -1953,7 +1953,7 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
 
     cdef cppclass CStrftimeOptions \
             "arrow::compute::StrftimeOptions"(CFunctionOptions):
-        CStrftimeOptions(c_string format)
+        CStrftimeOptions(c_string format, c_string locale)
 
     cdef cppclass CDayOfWeekOptions \
             "arrow::compute::DayOfWeekOptions"(CFunctionOptions):
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 3d62757a919..0fa1b18672b 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -1416,6 +1416,13 @@ def _fix_timestamp(s):
         expected = pa.array(_fix_timestamp(ts.strftime("%S.%f")))
         assert result.equals(expected)
 
+        # Test setting locale
+        tsa = pa.array(ts, type=pa.timestamp("s", timezone))
+        options = pc.StrftimeOptions("%Y-%m-%dT%H:%M:%SZ", "C")
+        result = pc.strftime(tsa, options=options)
+        expected = pa.array(_fix_timestamp(ts.strftime("%Y-%m-%dT%H:%M:%SZ")))
+        assert result.equals(expected)
+
     for unit in ["s", "ms", "us", "ns"]:
         tsa = pa.array(ts, type=pa.timestamp(unit))
         for fmt in formats:
diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index b33dec0f27d..263faad02b0 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -298,11 +298,15 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
 
   if (func_name == "strftime") {
     using Options = arrow::compute::StrftimeOptions;
-    auto out = std::make_shared<Options>(Options());
+    std::string format = "%Y-%m-%dT%H:%M:%SZ";
+    std::string locale = "C";
     if (!Rf_isNull(options["format"])) {
-      out->format = cpp11::as_cpp<std::string>(options["format"]);
+      format = cpp11::as_cpp<std::string>(options["format"]);
     }
-    return out;
+    if (!Rf_isNull(options["locale"])) {
+      locale = cpp11::as_cpp<std::string>(options["locale"]);
+    }
+    return std::make_shared<Options>(Options(format, locale));
   }
 
   if (func_name == "split_pattern" || func_name == "split_pattern_regex") {

From 00d685d02b01adca59926e97313fe4ab982a821f Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Mon, 26 Jul 2021 16:28:58 +0200
Subject: [PATCH 05/10] Removing R logic.

---
 r/configure.win   |  2 +-
 r/src/compute.cpp | 13 -------------
 2 files changed, 1 insertion(+), 14 deletions(-)

diff --git a/r/configure.win b/r/configure.win
index ce68a41b353..d830a238c39 100644
--- a/r/configure.win
+++ b/r/configure.win
@@ -44,7 +44,7 @@ else
   RWINLIB="../windows/$(ls windows/ | grep ^arrow- | tail -n 1)"
 fi
 OPENSSL_LIBS="-lcrypto -lcrypt32"
-MIMALLOC_LIBS="-lbcrypt -lpsapi -lole32"
+MIMALLOC_LIBS="-lbcrypt -lpsapi"
 AWS_LIBS="-laws-cpp-sdk-config -laws-cpp-sdk-transfer -laws-cpp-sdk-identity-management -laws-cpp-sdk-cognito-identity -laws-cpp-sdk-sts -laws-cpp-sdk-s3 -laws-cpp-sdk-core -laws-c-event-stream -laws-checksums -laws-c-common -lUserenv -lversion -lws2_32 -lBcrypt -lWininet -lwinhttp"
 
 # NOTE: If you make changes to the libraries below, you should also change
diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index 263faad02b0..0695e2525f7 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -296,19 +296,6 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
         cpp11::as_cpp<arrow::TimeUnit::type>(options["unit"]));
   }
 
-  if (func_name == "strftime") {
-    using Options = arrow::compute::StrftimeOptions;
-    std::string format = "%Y-%m-%dT%H:%M:%SZ";
-    std::string locale = "C";
-    if (!Rf_isNull(options["format"])) {
-      format = cpp11::as_cpp<std::string>(options["format"]);
-    }
-    if (!Rf_isNull(options["locale"])) {
-      locale = cpp11::as_cpp<std::string>(options["locale"]);
-    }
-    return std::make_shared<Options>(Options(format, locale));
-  }
-
   if (func_name == "split_pattern" || func_name == "split_pattern_regex") {
     using Options = arrow::compute::SplitPatternOptions;
     int64_t max_splits = -1;

From 2c9970a3fdc5455e717347149bdd60fbe416ec8d Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Tue, 27 Jul 2021 16:21:12 +0200
Subject: [PATCH 06/10] Changing locale instantiation.

---
 cpp/src/arrow/compute/api_scalar.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index d9eb4b94978..aa87b773058 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -242,7 +242,7 @@ constexpr char StrptimeOptions::kTypeName[];
 
 StrftimeOptions::StrftimeOptions(std::string format, std::string locale)
     : FunctionOptions(internal::kStrftimeOptionsType), format(std::move(format)) {
-  loc = std::locale(locale);
+  loc = std::locale(locale.c_str());
 }
 StrftimeOptions::StrftimeOptions(std::string format)
     : FunctionOptions(internal::kStrftimeOptionsType), format(std::move(format)) {

From 5ca3f22700ad3d6b4fa65a7c010333744e395b5e Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Wed, 28 Jul 2021 16:08:56 +0200
Subject: [PATCH 07/10] Review feedback.

---
 cpp/src/arrow/compute/api_scalar.cc           | 10 +---
 cpp/src/arrow/compute/api_scalar.h            | 13 ++--
 .../arrow/compute/kernels/scalar_temporal.cc  | 60 +++++++++++--------
 3 files changed, 44 insertions(+), 39 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index aa87b773058..a7a61478d75 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -241,13 +241,9 @@ StrptimeOptions::StrptimeOptions() : StrptimeOptions("", TimeUnit::SECOND) {}
 constexpr char StrptimeOptions::kTypeName[];
 
 StrftimeOptions::StrftimeOptions(std::string format, std::string locale)
-    : FunctionOptions(internal::kStrftimeOptionsType), format(std::move(format)) {
-  loc = std::locale(locale.c_str());
-}
-StrftimeOptions::StrftimeOptions(std::string format)
-    : FunctionOptions(internal::kStrftimeOptionsType), format(std::move(format)) {
-  loc = std::locale("C");
-}
+    : FunctionOptions(internal::kStrftimeOptionsType),
+      format(std::move(format)),
+      locale(std::move(locale)) {}
 StrftimeOptions::StrftimeOptions() : StrftimeOptions("%Y-%m-%dT%H:%M:%SZ") {}
 constexpr char StrftimeOptions::kTypeName[];
 
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index aa9359eae48..15ed11721b3 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -29,7 +29,6 @@
 #include "arrow/result.h"
 #include "arrow/util/macros.h"
 #include "arrow/util/visibility.h"
-#include "arrow/vendored/datetime.h"
 
 namespace arrow {
 namespace compute {
@@ -181,15 +180,14 @@ class ARROW_EXPORT StrptimeOptions : public FunctionOptions {
 
 class ARROW_EXPORT StrftimeOptions : public FunctionOptions {
  public:
-  explicit StrftimeOptions(std::string format, std::string locale);
-  explicit StrftimeOptions(std::string format);
+  explicit StrftimeOptions(std::string format, std::string locale = "C");
   StrftimeOptions();
   constexpr static char const kTypeName[] = "StrftimeOptions";
 
   /// The desired format string.
   std::string format;
-  /// The desired output locale.
-  std::locale loc;
+  /// The desired output locale string.
+  std::string locale;
 };
 
 class ARROW_EXPORT PadOptions : public FunctionOptions {
@@ -1013,10 +1011,11 @@ Result<Datum> Nanosecond(const Datum& values, ExecContext* ctx = NULLPTR);
 /// \note API not yet finalized
 ARROW_EXPORT Result<Datum> Subsecond(const Datum& values, ExecContext* ctx = NULLPTR);
 
-/// \brief Strftime
+/// \brief Strftime returns formatted time strings as specified by time format string and
+/// locale string for each element of `values`.
 ///
 /// \param[in] values input to print time string from
-/// \param[in] options for setting time format
+/// \param[in] options for setting time format string and locale
 /// \param[in] ctx the function execution context, optional
 /// \return the resulting datum
 ///
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index 43391270b49..491042a687c 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -448,16 +448,9 @@ struct Nanosecond {
 // ----------------------------------------------------------------------
 // Convert timestamps to a string representation with an arbitrary format
 
-template <typename Duration>
-inline std::string get_timestamp(int64_t arg, const std::locale* locale,
-                                 const time_zone* tz, const std::string* format) {
-  auto zt =
-      arrow_vendored::date::zoned_time<Duration>{tz, sys_time<Duration>(Duration{arg})};
-  return arrow_vendored::date::format(*locale, *format, zt);
-}
-
 template <typename Duration>
 struct Strftime {
+#ifndef _WIN32
   static Status Call(KernelContext* ctx, const Scalar& in, Scalar* out) {
     const auto& timezone = GetInputTimezone(in);
     if (timezone.empty()) {
@@ -467,11 +460,12 @@ struct Strftime {
     const arrow_vendored::date::time_zone* tz =
         arrow_vendored::date::locate_zone(timezone);
     const StrftimeOptions options = StrftimeState::Get(ctx);
+    const std::locale locale = std::locale(options.locale.c_str());
 
     if (in.is_valid) {
       const auto& in_val = internal::UnboxScalar<const TimestampType>::Unbox(in);
-      *checked_cast<StringScalar*>(out) = StringScalar(
-          get_timestamp<Duration>(in_val, &options.loc, tz, &options.format));
+      *checked_cast<StringScalar*>(out) =
+          StringScalar(strftime(in_val, &locale, tz, &options.format));
     } else {
       out->is_valid = false;
     }
@@ -486,27 +480,43 @@ struct Strftime {
     const arrow_vendored::date::time_zone* tz =
         arrow_vendored::date::locate_zone(timezone);
     const StrftimeOptions options = StrftimeState::Get(ctx);
+    const std::locale locale = std::locale(options.locale.c_str());
 
-    std::unique_ptr<ArrayBuilder> array_builder;
-    RETURN_NOT_OK(MakeBuilder(ctx->memory_pool(), utf8(), &array_builder));
-    StringBuilder* string_builder = checked_cast<StringBuilder*>(array_builder.get());
-    auto expected_string_size = static_cast<int64_t>(
-        ceil(get_timestamp<Duration>(0, &options.loc, tz, &options.format).size() * 1.1));
-    RETURN_NOT_OK(string_builder->Reserve(in.length * expected_string_size));
+    StringBuilder string_builder;
+    auto string_size = static_cast<int64_t>(
+        ceil(strftime(-1, &locale, tz, &options.format).size() * 1.1));
+    RETURN_NOT_OK(string_builder.Reserve(in.length));
+    RETURN_NOT_OK(
+        string_builder.ReserveData((in.length - in.GetNullCount()) * string_size));
 
-    auto visit_null = [&]() { return string_builder->AppendNull(); };
+    auto visit_null = [&]() { return string_builder.AppendNull(); };
     auto visit_value = [&](int64_t arg) {
-      return string_builder->Append(
-          get_timestamp<Duration>(arg, &options.loc, tz, &options.format));
+      return string_builder.Append(strftime(arg, &locale, tz, &options.format));
     };
     RETURN_NOT_OK(VisitArrayDataInline<Int64Type>(in, visit_value, visit_null));
 
     std::shared_ptr<Array> out_array;
-    RETURN_NOT_OK(string_builder->Finish(&out_array));
+    RETURN_NOT_OK(string_builder.Finish(&out_array));
     *out = *std::move(out_array->data());
 
     return Status::OK();
   }
+
+ private:
+  static std::string strftime(int64_t arg, const std::locale* locale, const time_zone* tz,
+                              const std::string* format) {
+    auto zt =
+        arrow_vendored::date::zoned_time<Duration>{tz, sys_time<Duration>(Duration{arg})};
+    return arrow_vendored::date::format(*locale, *format, zt);
+  }
+#else
+  static Status Call(KernelContext* ctx, const Scalar& in, Scalar* out) {
+    return Status::NotImplemented("Strftime not yet implemented on windows.");
+  }
+  static Status Call(KernelContext* ctx, const ArrayData& in, ArrayData* out) {
+    return Status::NotImplemented("Strftime not yet implemented on windows.");
+  }
+#endif
 };
 
 // ----------------------------------------------------------------------
@@ -814,9 +824,11 @@ const FunctionDoc subsecond_doc{
     {"values"}};
 
 const FunctionDoc strftime_doc{
-    "Convert timestamps to a string representation with an arbitrary format",
-    ("Strftime returns a string representation with an arbitrary format.\n"
-     "The time format string can be set via options."),
+    "Convert timestamp to a string",
+    ("Strftime returns a string representation of a timestmap with a given format "
+     "and locale.\n"
+     "The time format string and locale can be set via options.\n"
+     "Returns an error if timestamp does not have a defined timezone."),
     {"values"},
     "StrftimeOptions"};
 
@@ -890,12 +902,10 @@ void RegisterScalarTemporal(FunctionRegistry* registry) {
       "subsecond", float64(), &subsecond_doc);
   DCHECK_OK(registry->AddFunction(std::move(subsecond)));
 
-#ifndef _WIN32
   static auto default_strftime_options = StrftimeOptions();
   auto strftime = MakeStrftime("strftime", &strftime_doc, default_strftime_options,
                                StrftimeState::Init);
   DCHECK_OK(registry->AddFunction(std::move(strftime)));
-#endif
 }
 
 }  // namespace internal

From 91600d942ee2d9aa2dbbf932e123787a3f668bb4 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Fri, 6 Aug 2021 02:32:57 +0200
Subject: [PATCH 08/10] Refactor MakeTemporal.

---
 cpp/src/arrow/compute/api_scalar.h            |   2 +-
 .../arrow/compute/kernels/scalar_temporal.cc  | 118 ++++++------------
 r/tests/testthat/test-dplyr-lubridate.R       |   1 +
 3 files changed, 42 insertions(+), 79 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 15ed11721b3..5ff727e8b6b 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -1019,7 +1019,7 @@ ARROW_EXPORT Result<Datum> Subsecond(const Datum& values, ExecContext* ctx = NUL
 /// \param[in] ctx the function execution context, optional
 /// \return the resulting datum
 ///
-/// \since 5.0.0
+/// \since 6.0.0
 /// \note API not yet finalized
 ARROW_EXPORT Result<Datum> Strftime(const Datum& values, StrftimeOptions options,
                                     ExecContext* ctx = NULLPTR);
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index 491042a687c..acd8062a12d 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -75,6 +75,16 @@ const std::string& GetInputTimezone(const ArrayData& array) {
   return checked_cast<const TimestampType&>(*array.type).timezone();
 }
 
+Result<const time_zone*> LocateZone(std::string timezone) {
+  const time_zone* tz;
+  try {
+    tz = locate_zone(timezone);
+  } catch (const std::runtime_error& ex) {
+    return Status::Invalid(ex.what());
+  }
+  return tz;
+}
+
 struct NonZonedLocalizer {
   // No-op conversions: UTC -> UTC
   template <typename Duration>
@@ -118,12 +128,7 @@ struct TemporalComponentExtractBase {
           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());
-      }
+      ARROW_ASSIGN_OR_RAISE(auto tz, LocateZone(timezone));
       using ExecTemplate = Op<Duration, ZonedLocalizer>;
       auto op = ExecTemplate(options, ZonedLocalizer{tz});
       applicator::ScalarUnaryNotNullStateful<OutType, TimestampType, ExecTemplate> kernel{
@@ -448,24 +453,31 @@ struct Nanosecond {
 // ----------------------------------------------------------------------
 // Convert timestamps to a string representation with an arbitrary format
 
+#ifndef _WIN32
+template <typename Duration>
+inline static std::string strftime(int64_t arg, const std::locale* locale,
+                                   const time_zone* tz, const std::string* format) {
+  auto zt =
+      arrow_vendored::date::zoned_time<Duration>{tz, sys_time<Duration>(Duration{arg})};
+  return arrow_vendored::date::format(*locale, *format, zt);
+}
+
 template <typename Duration>
 struct Strftime {
-#ifndef _WIN32
   static Status Call(KernelContext* ctx, const Scalar& in, Scalar* out) {
     const auto& timezone = GetInputTimezone(in);
     if (timezone.empty()) {
       return Status::Invalid(
           "Timestamps without a time zone cannot be reliably printed.");
     }
-    const arrow_vendored::date::time_zone* tz =
-        arrow_vendored::date::locate_zone(timezone);
+    ARROW_ASSIGN_OR_RAISE(auto tz, LocateZone(timezone));
     const StrftimeOptions options = StrftimeState::Get(ctx);
     const std::locale locale = std::locale(options.locale.c_str());
 
     if (in.is_valid) {
       const auto& in_val = internal::UnboxScalar<const TimestampType>::Unbox(in);
       *checked_cast<StringScalar*>(out) =
-          StringScalar(strftime(in_val, &locale, tz, &options.format));
+          StringScalar(strftime<Duration>(in_val, &locale, tz, &options.format));
     } else {
       out->is_valid = false;
     }
@@ -477,21 +489,20 @@ struct Strftime {
     if (timezone.empty()) {
       return Status::Invalid("Timestamp without a time zone cannot be reliably printed.");
     }
-    const arrow_vendored::date::time_zone* tz =
-        arrow_vendored::date::locate_zone(timezone);
+    ARROW_ASSIGN_OR_RAISE(auto tz, LocateZone(timezone));
     const StrftimeOptions options = StrftimeState::Get(ctx);
     const std::locale locale = std::locale(options.locale.c_str());
 
     StringBuilder string_builder;
     auto string_size = static_cast<int64_t>(
-        ceil(strftime(-1, &locale, tz, &options.format).size() * 1.1));
+        ceil(strftime<Duration>(-1, &locale, tz, &options.format).size() * 1.1));
     RETURN_NOT_OK(string_builder.Reserve(in.length));
     RETURN_NOT_OK(
         string_builder.ReserveData((in.length - in.GetNullCount()) * string_size));
 
     auto visit_null = [&]() { return string_builder.AppendNull(); };
     auto visit_value = [&](int64_t arg) {
-      return string_builder.Append(strftime(arg, &locale, tz, &options.format));
+      return string_builder.Append(strftime<Duration>(arg, &locale, tz, &options.format));
     };
     RETURN_NOT_OK(VisitArrayDataInline<Int64Type>(in, visit_value, visit_null));
 
@@ -501,15 +512,9 @@ struct Strftime {
 
     return Status::OK();
   }
-
- private:
-  static std::string strftime(int64_t arg, const std::locale* locale, const time_zone* tz,
-                              const std::string* format) {
-    auto zt =
-        arrow_vendored::date::zoned_time<Duration>{tz, sys_time<Duration>(Duration{arg})};
-    return arrow_vendored::date::format(*locale, *format, zt);
-  }
 #else
+template <typename Duration>
+struct Strftime {
   static Status Call(KernelContext* ctx, const Scalar& in, Scalar* out) {
     return Status::NotImplemented("Strftime not yet implemented on windows.");
   }
@@ -548,12 +553,8 @@ struct ISOCalendar {
       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());
-        }
+        ARROW_ASSIGN_OR_RAISE(auto tz, LocateZone(timezone));
+        iso_calendar = GetIsoCalendar<Duration>(in_val, ZonedLocalizer{tz});
       }
       ScalarVector values = {std::make_shared<Int64Scalar>(iso_calendar[0]),
                              std::make_shared<Int64Scalar>(iso_calendar[1]),
@@ -593,19 +594,15 @@ struct ISOCalendar {
       };
       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());
-      }
+      ARROW_ASSIGN_OR_RAISE(auto tz, LocateZone(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));
     }
 
     std::shared_ptr<Array> out_array;
@@ -655,41 +652,6 @@ std::shared_ptr<ScalarFunction> MakeTemporal(
   return func;
 }
 
-std::shared_ptr<ScalarFunction> MakeStrftime(std::string name, const FunctionDoc* doc,
-                                             const StrftimeOptions& default_options,
-                                             KernelInit init) {
-  const auto& out_type = utf8();
-  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<Strftime<std::chrono::seconds>>;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
-        break;
-      }
-      case TimeUnit::MILLI: {
-        auto exec = SimpleUnary<Strftime<std::chrono::milliseconds>>;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
-        break;
-      }
-      case TimeUnit::MICRO: {
-        auto exec = SimpleUnary<Strftime<std::chrono::microseconds>>;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
-        break;
-      }
-      case TimeUnit::NANO: {
-        auto exec = SimpleUnary<Strftime<std::chrono::nanoseconds>>;
-        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
-        break;
-      }
-    }
-  }
-  return func;
-}
-
 template <template <typename...> class Op>
 std::shared_ptr<ScalarFunction> MakeSimpleUnaryTemporal(
     std::string name, const std::shared_ptr<arrow::DataType> out_type,
@@ -903,8 +865,8 @@ void RegisterScalarTemporal(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(subsecond)));
 
   static auto default_strftime_options = StrftimeOptions();
-  auto strftime = MakeStrftime("strftime", &strftime_doc, default_strftime_options,
-                               StrftimeState::Init);
+  auto strftime = MakeSimpleUnaryTemporal<Strftime>(
+      "strftime", utf8(), &strftime_doc, &default_strftime_options, StrftimeState::Init);
   DCHECK_OK(registry->AddFunction(std::move(strftime)));
 }
 
diff --git a/r/tests/testthat/test-dplyr-lubridate.R b/r/tests/testthat/test-dplyr-lubridate.R
index d216ec82c1e..64bb42a0ecf 100644
--- a/r/tests/testthat/test-dplyr-lubridate.R
+++ b/r/tests/testthat/test-dplyr-lubridate.R
@@ -26,6 +26,7 @@ library(dplyr)
 # TODO: consider reevaluating this workaround after ARROW-12980
 withr::local_timezone("UTC")
 
+# TODO: We should test on windows once ARROW-13168 is resolved.
 if (tolower(Sys.info()[["sysname"]]) == "windows") {
   test_date <- as.POSIXct("2017-01-01 00:00:12.3456789", tz = "")
 } else {

From 989d2dd73b1739e96de795919341c99867b936d9 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Wed, 18 Aug 2021 15:55:02 +0200
Subject: [PATCH 09/10] Various changes and improvements

---
 cpp/src/arrow/compute/api_scalar.cc           |   3 +-
 cpp/src/arrow/compute/api_scalar.h            |  13 +-
 .../arrow/compute/kernels/scalar_temporal.cc  | 130 ++++++++++++------
 .../compute/kernels/scalar_temporal_test.cc   |  57 ++++++--
 cpp/src/arrow/testing/gtest_util.cc           |   9 ++
 cpp/src/arrow/testing/gtest_util.h            |   3 +
 docs/source/cpp/compute.rst                   |  19 ++-
 python/pyarrow/tests/test_compute.py          |  12 +-
 8 files changed, 172 insertions(+), 74 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index a7a61478d75..b0aeec7c92e 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -244,8 +244,9 @@ StrftimeOptions::StrftimeOptions(std::string format, std::string locale)
     : FunctionOptions(internal::kStrftimeOptionsType),
       format(std::move(format)),
       locale(std::move(locale)) {}
-StrftimeOptions::StrftimeOptions() : StrftimeOptions("%Y-%m-%dT%H:%M:%SZ") {}
+StrftimeOptions::StrftimeOptions() : StrftimeOptions(kDefaultFormat) {}
 constexpr char StrftimeOptions::kTypeName[];
+constexpr const char* StrftimeOptions::kDefaultFormat;
 
 PadOptions::PadOptions(int64_t width, std::string padding)
     : FunctionOptions(internal::kPadOptionsType),
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 5ff727e8b6b..f1672a05223 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -182,8 +182,11 @@ class ARROW_EXPORT StrftimeOptions : public FunctionOptions {
  public:
   explicit StrftimeOptions(std::string format, std::string locale = "C");
   StrftimeOptions();
+
   constexpr static char const kTypeName[] = "StrftimeOptions";
 
+  constexpr static const char* kDefaultFormat = "%Y-%m-%dT%H:%M:%SZ";
+
   /// The desired format string.
   std::string format;
   /// The desired output locale string.
@@ -1011,11 +1014,13 @@ Result<Datum> Nanosecond(const Datum& values, ExecContext* ctx = NULLPTR);
 /// \note API not yet finalized
 ARROW_EXPORT Result<Datum> Subsecond(const Datum& values, ExecContext* ctx = NULLPTR);
 
-/// \brief Strftime returns formatted time strings as specified by time format string and
-/// locale string for each element of `values`.
+/// \brief Format timestamps according to a format string
+///
+/// Return formatted time strings according to the format string
+/// `StrftimeOptions::format` and to the locale specifier `Strftime::locale`.
 ///
-/// \param[in] values input to print time string from
-/// \param[in] options for setting time format string and locale
+/// \param[in] values input timestamps
+/// \param[in] options for setting format string and locale
 /// \param[in] ctx the function execution context, optional
 /// \return the resulting datum
 ///
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index acd8062a12d..552484deb6f 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -15,6 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <sstream>
+
 #include "arrow/builder.h"
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/kernels/common.h"
@@ -63,6 +65,10 @@ const std::shared_ptr<DataType>& IsoCalendarType() {
   return type;
 }
 
+const std::string& GetInputTimezone(const DataType& type) {
+  return checked_cast<const TimestampType&>(type).timezone();
+}
+
 const std::string& GetInputTimezone(const Datum& datum) {
   return checked_cast<const TimestampType&>(*datum.type()).timezone();
 }
@@ -75,14 +81,20 @@ const std::string& GetInputTimezone(const ArrayData& array) {
   return checked_cast<const TimestampType&>(*array.type).timezone();
 }
 
-Result<const time_zone*> LocateZone(std::string timezone) {
-  const time_zone* tz;
+Result<const time_zone*> LocateZone(const std::string& timezone) {
+  try {
+    return locate_zone(timezone);
+  } catch (const std::runtime_error& ex) {
+    return Status::Invalid("Cannot locate timezone '", timezone, "': ", ex.what());
+  }
+}
+
+Result<std::locale> GetLocale(const std::string& locale) {
   try {
-    tz = locate_zone(timezone);
+    return std::locale(locale);
   } catch (const std::runtime_error& ex) {
-    return Status::Invalid(ex.what());
+    return Status::Invalid("Cannot find locale '", locale, "': ", ex.what());
   }
-  return tz;
 }
 
 struct NonZonedLocalizer {
@@ -454,30 +466,35 @@ struct Nanosecond {
 // Convert timestamps to a string representation with an arbitrary format
 
 #ifndef _WIN32
-template <typename Duration>
-inline static std::string strftime(int64_t arg, const std::locale* locale,
-                                   const time_zone* tz, const std::string* format) {
-  auto zt =
-      arrow_vendored::date::zoned_time<Duration>{tz, sys_time<Duration>(Duration{arg})};
-  return arrow_vendored::date::format(*locale, *format, zt);
-}
-
 template <typename Duration>
 struct Strftime {
-  static Status Call(KernelContext* ctx, const Scalar& in, Scalar* out) {
-    const auto& timezone = GetInputTimezone(in);
+  const StrftimeOptions& options;
+  const time_zone* tz;
+  const std::locale locale;
+
+  static Result<Strftime> Make(KernelContext* ctx, const DataType& type) {
+    const StrftimeOptions& options = StrftimeState::Get(ctx);
+
+    const auto& timezone = GetInputTimezone(type);
     if (timezone.empty()) {
       return Status::Invalid(
-          "Timestamps without a time zone cannot be reliably printed.");
+          "Timestamps without a time zone cannot be reliably formatted.");
     }
-    ARROW_ASSIGN_OR_RAISE(auto tz, LocateZone(timezone));
-    const StrftimeOptions options = StrftimeState::Get(ctx);
-    const std::locale locale = std::locale(options.locale.c_str());
+    ARROW_ASSIGN_OR_RAISE(const time_zone* tz, LocateZone(timezone));
+
+    ARROW_ASSIGN_OR_RAISE(std::locale locale, GetLocale(options.locale));
+
+    return Strftime{options, tz, std::move(locale)};
+  }
+
+  static Status Call(KernelContext* ctx, const Scalar& in, Scalar* out) {
+    ARROW_ASSIGN_OR_RAISE(auto self, Make(ctx, *in.type));
+    TimestampFormatter formatter{self.options.format, self.tz, self.locale};
 
     if (in.is_valid) {
-      const auto& in_val = internal::UnboxScalar<const TimestampType>::Unbox(in);
-      *checked_cast<StringScalar*>(out) =
-          StringScalar(strftime<Duration>(in_val, &locale, tz, &options.format));
+      const int64_t in_val = internal::UnboxScalar<const TimestampType>::Unbox(in);
+      ARROW_ASSIGN_OR_RAISE(auto formatted, formatter(in_val));
+      checked_cast<StringScalar*>(out)->value = Buffer::FromString(std::move(formatted));
     } else {
       out->is_valid = false;
     }
@@ -485,24 +502,23 @@ struct Strftime {
   }
 
   static Status Call(KernelContext* ctx, const ArrayData& in, ArrayData* out) {
-    const auto& timezone = GetInputTimezone(in);
-    if (timezone.empty()) {
-      return Status::Invalid("Timestamp without a time zone cannot be reliably printed.");
-    }
-    ARROW_ASSIGN_OR_RAISE(auto tz, LocateZone(timezone));
-    const StrftimeOptions options = StrftimeState::Get(ctx);
-    const std::locale locale = std::locale(options.locale.c_str());
+    ARROW_ASSIGN_OR_RAISE(auto self, Make(ctx, *in.type));
+    TimestampFormatter formatter{self.options.format, self.tz, self.locale};
 
     StringBuilder string_builder;
-    auto string_size = static_cast<int64_t>(
-        ceil(strftime<Duration>(-1, &locale, tz, &options.format).size() * 1.1));
-    RETURN_NOT_OK(string_builder.Reserve(in.length));
-    RETURN_NOT_OK(
-        string_builder.ReserveData((in.length - in.GetNullCount()) * string_size));
+    // Presize string data using a heuristic
+    {
+      ARROW_ASSIGN_OR_RAISE(auto formatted, formatter(42));
+      const auto string_size = static_cast<int64_t>(ceil(formatted.size() * 1.1));
+      RETURN_NOT_OK(string_builder.Reserve(in.length));
+      RETURN_NOT_OK(
+          string_builder.ReserveData((in.length - in.GetNullCount()) * string_size));
+    }
 
     auto visit_null = [&]() { return string_builder.AppendNull(); };
     auto visit_value = [&](int64_t arg) {
-      return string_builder.Append(strftime<Duration>(arg, &locale, tz, &options.format));
+      ARROW_ASSIGN_OR_RAISE(auto formatted, formatter(arg));
+      return string_builder.Append(std::move(formatted));
     };
     RETURN_NOT_OK(VisitArrayDataInline<Int64Type>(in, visit_value, visit_null));
 
@@ -512,6 +528,36 @@ struct Strftime {
 
     return Status::OK();
   }
+
+  struct TimestampFormatter {
+    const char* format;
+    const time_zone* tz;
+    std::ostringstream bufstream;
+
+    explicit TimestampFormatter(const std::string& format, const time_zone* tz,
+                                const std::locale& locale)
+        : format(format.c_str()), tz(tz) {
+      bufstream.imbue(locale);
+      // Propagate errors as C++ exceptions (to get an actual error message)
+      bufstream.exceptions(std::ios::failbit | std::ios::badbit);
+    }
+
+    Result<std::string> operator()(int64_t arg) {
+      bufstream.str("");
+      const auto zt = arrow_vendored::date::zoned_time<Duration>{
+          tz, sys_time<Duration>(Duration{arg})};
+      try {
+        arrow_vendored::date::to_stream(bufstream, format, zt);
+      } catch (const std::runtime_error& ex) {
+        bufstream.clear();
+        return Status::Invalid("Failed formatting timestamp: ", ex.what());
+      }
+      // XXX could return a view with std::ostringstream::view() (C++20)
+      return std::move(bufstream).str();
+    }
+  };
+};
+
 #else
 template <typename Duration>
 struct Strftime {
@@ -521,8 +567,8 @@ struct Strftime {
   static Status Call(KernelContext* ctx, const ArrayData& in, ArrayData* out) {
     return Status::NotImplemented("Strftime not yet implemented on windows.");
   }
-#endif
 };
+#endif
 
 // ----------------------------------------------------------------------
 // Extract ISO calendar values from timestamp
@@ -786,12 +832,12 @@ const FunctionDoc subsecond_doc{
     {"values"}};
 
 const FunctionDoc strftime_doc{
-    "Convert timestamp to a string",
-    ("Strftime returns a string representation of a timestmap with a given format "
-     "and locale.\n"
-     "The time format string and locale can be set via options.\n"
-     "Returns an error if timestamp does not have a defined timezone."),
-    {"values"},
+    "Format timestamps according to a format string",
+    ("For each input timestamp, emit a formatted string.\n"
+     "The time format string and locale can be set using StrftimeOptions.\n"
+     "An error is returned if the timestamps don't have a defined timezone,\n"
+     "or if the timezone cannot be found in the timezone database."),
+    {"timestamps"},
     "StrftimeOptions"};
 
 }  // namespace
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
index c29ac9522e1..d8199089328 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
@@ -388,13 +388,15 @@ TEST_F(ScalarTemporalTest, Strftime) {
   auto options_default = StrftimeOptions();
   auto options = StrftimeOptions("%Y-%m-%dT%H:%M:%S%z");
 
-  const char* seconds = R"(["1970-01-01T00:00:59", null])";
+  const char* seconds = R"(["1970-01-01T00:00:59", "2021-08-18T15:11:50", null])";
   const char* milliseconds = R"(["1970-01-01T00:00:59.123", null])";
   const char* microseconds = R"(["1970-01-01T00:00:59.123456", null])";
   const char* nanoseconds = R"(["1970-01-01T00:00:59.123456789", null])";
 
-  const char* default_seconds = R"(["1970-01-01T00:00:59Z", null])";
-  const char* string_seconds = R"(["1970-01-01T00:00:59+0000", null])";
+  const char* default_seconds = R"(
+      ["1970-01-01T00:00:59Z", "2021-08-18T15:11:50Z", null])";
+  const char* string_seconds = R"(
+      ["1970-01-01T00:00:59+0000", "2021-08-18T15:11:50+0000", null])";
   const char* string_milliseconds = R"(["1970-01-01T00:00:59.123+0000", null])";
   const char* string_microseconds = R"(["1970-01-01T05:30:59.123456+0530", null])";
   const char* string_nanoseconds = R"(["1969-12-31T14:00:59.123456789-1000", null])";
@@ -409,13 +411,26 @@ TEST_F(ScalarTemporalTest, Strftime) {
                    utf8(), string_microseconds, &options);
   CheckScalarUnary("strftime", timestamp(TimeUnit::NANO, "US/Hawaii"), nanoseconds,
                    utf8(), string_nanoseconds, &options);
+}
 
-  auto naive_times = ArrayFromJSON(timestamp(TimeUnit::SECOND), seconds);
-  ASSERT_RAISES(Invalid, Strftime(naive_times, options_default));
-  ASSERT_RAISES(Invalid, Strftime(naive_times, options));
+TEST_F(ScalarTemporalTest, StrftimeNoTimezone) {
+  const char* seconds = R"(["1970-01-01T00:00:59", null])";
+  auto arr = ArrayFromJSON(timestamp(TimeUnit::SECOND), seconds);
+  EXPECT_RAISES_WITH_MESSAGE_THAT(
+      Invalid,
+      testing::HasSubstr("Timestamps without a time zone cannot be reliably formatted"),
+      Strftime(arr, StrftimeOptions()));
 }
 
-TEST_F(ScalarTemporalTest, StrftimeWithLocale) {
+TEST_F(ScalarTemporalTest, StrftimeInvalidTimezone) {
+  const char* seconds = R"(["1970-01-01T00:00:59", null])";
+  auto arr = ArrayFromJSON(timestamp(TimeUnit::SECOND, "non-existent"), seconds);
+  EXPECT_RAISES_WITH_MESSAGE_THAT(
+      Invalid, testing::HasSubstr("Cannot locate timezone 'non-existent'"),
+      Strftime(arr, StrftimeOptions()));
+}
+
+TEST_F(ScalarTemporalTest, StrftimeCLocale) {
   auto options_default = StrftimeOptions();
   auto options = StrftimeOptions("%Y-%m-%dT%H:%M:%S%z", "C");
   auto options_locale_specific = StrftimeOptions("%a", "C");
@@ -446,11 +461,33 @@ TEST_F(ScalarTemporalTest, StrftimeWithLocale) {
 
   CheckScalarUnary("strftime", timestamp(TimeUnit::NANO, "US/Hawaii"), nanoseconds,
                    utf8(), string_locale_specific, &options_locale_specific);
+}
 
-  auto naive_times = ArrayFromJSON(timestamp(TimeUnit::SECOND), seconds);
-  ASSERT_RAISES(Invalid, Strftime(naive_times, options_default));
-  ASSERT_RAISES(Invalid, Strftime(naive_times, options));
+TEST_F(ScalarTemporalTest, StrftimeOtherLocale) {
+  if (!LocaleExists("fr_FR.UTF-8")) {
+    GTEST_SKIP() << "locale 'fr_FR.UTF-8' doesn't exist on this system";
+  }
+
+  auto options = StrftimeOptions("%d %B %Y %H:%M:%S", "fr_FR.UTF-8");
+  const char* milliseconds = R"(
+      ["1970-01-01T00:00:59.123", "2021-08-18T15:11:50.456", null])";
+  const char* expected = R"(
+      ["01 janvier 1970 00:00:59,123", "18 août 2021 15:11:50,456", null])";
+  CheckScalarUnary("strftime", timestamp(TimeUnit::MILLI, "UTC"), milliseconds, utf8(),
+                   expected, &options);
+}
+
+TEST_F(ScalarTemporalTest, StrftimeInvalidLocale) {
+  auto options = StrftimeOptions("%d %B %Y %H:%M:%S", "non-existent");
+  const char* seconds = R"(["1970-01-01T00:00:59", null])";
+  auto arr = ArrayFromJSON(timestamp(TimeUnit::SECOND, "UTC"), seconds);
+
+  EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid,
+                                  testing::HasSubstr("Cannot find locale 'non-existent'"),
+                                  Strftime(arr, options));
 }
+
 #endif
+
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/testing/gtest_util.cc b/cpp/src/arrow/testing/gtest_util.cc
index 30cc59800f4..6147201a32e 100644
--- a/cpp/src/arrow/testing/gtest_util.cc
+++ b/cpp/src/arrow/testing/gtest_util.cc
@@ -566,6 +566,15 @@ std::shared_ptr<Array> TweakValidityBit(const std::shared_ptr<Array>& array,
   return MakeArray(data);
 }
 
+bool LocaleExists(const char* locale) {
+  try {
+    std::locale loc(locale);
+    return true;
+  } catch (std::runtime_error&) {
+    return false;
+  }
+}
+
 class LocaleGuard::Impl {
  public:
   explicit Impl(const char* new_locale) : global_locale_(std::locale()) {
diff --git a/cpp/src/arrow/testing/gtest_util.h b/cpp/src/arrow/testing/gtest_util.h
index 951fafdf968..3f9408ecdcb 100644
--- a/cpp/src/arrow/testing/gtest_util.h
+++ b/cpp/src/arrow/testing/gtest_util.h
@@ -494,6 +494,9 @@ std::vector<T> IteratorToVector(Iterator<T> iterator) {
   return out;
 }
 
+ARROW_TESTING_EXPORT
+bool LocaleExists(const char* locale);
+
 // A RAII-style object that switches to a new locale, and switches back
 // to the old locale when going out of scope.  Doesn't do anything if the
 // new locale doesn't exist on the local machine.
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index f29e2e5c6fa..aca7adfdf22 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -986,13 +986,15 @@ number of input and output types.  The type to cast to can be passed in a
 :struct:`CastOptions` instance.  As an alternative, the same service is
 provided by a concrete function :func:`~arrow::compute::Cast`.
 
-+--------------------------+------------+--------------------+-----------------------+--------------------------------------------+
-| Function name            | Arity      | Input types        | Output type           | Options class                              |
-+==========================+============+====================+=======================+============================================+
-| cast                     | Unary      | Many               | Variable              | :struct:`CastOptions`                      |
-+--------------------------+------------+--------------------+-----------------------+--------------------------------------------+
-| strptime                 | Unary      | String-like        | Timestamp             | :struct:`StrptimeOptions`                  |
-+--------------------------+------------+--------------------+-----------------------+--------------------------------------------+
++--------------------------+------------+--------------------+------------------+------------------------------+
+| Function name            | Arity      | Input types        | Output type      | Options class                |
++==========================+============+====================+==================+==============================+
+| cast                     | Unary      | Many               | Variable         | :struct:`CastOptions`        |
++--------------------------+------------+--------------------+------------------+------------------------------+
+| strftime                 | Unary      | Timestamp          | String           | :struct:`StrftimeOptions`    |
++--------------------------+------------+--------------------+------------------+------------------------------+
+| strptime                 | Unary      | String-like        | Timestamp        | :struct:`StrptimeOptions`    |
++--------------------------+------------+--------------------+------------------+------------------------------+
 
 The conversions available with ``cast`` are listed below.  In all cases, a
 null input value is converted into a null output value.
@@ -1120,8 +1122,6 @@ If the input timestamps have a non-empty timezone, localized timestamp component
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
 | subsecond          | Unary      | Timestamp         | Double        |                            |       |
 +--------------------+------------+-------------------+---------------+----------------------------+-------+
-| strftime           | Unary      | Temporal          | String        | :struct:`StrftimeOptions`  | \(4)  |
-+--------------------+------------+-------------------+---------------+----------------------------+-------+
 
 * \(1) Outputs the number of the day of the week. By default week begins on Monday
   represented by 0 and ends on Sunday represented by 6. :member:`DayOfWeekOptions::week_start` can be used to set
@@ -1131,7 +1131,6 @@ If the input timestamps have a non-empty timezone, localized timestamp component
   starts with the first ISO week.
   See `ISO 8601 week date definition`_ for more details.
 * \(3) Output is a ``{"iso_year": output type, "iso_week": output type, "iso_day_of_week":  output type}`` Struct.
-* \(4) Output is a timestamp string. To define timestamp format :member:`StrftimeOptions::format` can be used.
 
 .. _ISO 8601 week date definition: https://en.wikipedia.org/wiki/ISO_week_date#First_week
 
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 0fa1b18672b..c20d097f7c8 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -129,13 +129,11 @@ def test_option_class_equality():
         pc.SplitPatternOptions(pattern="pattern"),
         pc.StrptimeOptions("%Y", "s"),
         pc.TrimOptions(" "),
+        pc.StrftimeOptions(),
     ]
-    if sys.platform != 'win32':
-        options.append(pc.StrftimeOptions())
     classes = {type(option) for option in options}
     for cls in exported_option_classes:
-        if cls not in classes and sys.platform != 'win32' and \
-                cls != pc.StrftimeOptions:
+        if cls not in classes:
             try:
                 options.append(cls())
             except TypeError:
@@ -1426,9 +1424,9 @@ def _fix_timestamp(s):
     for unit in ["s", "ms", "us", "ns"]:
         tsa = pa.array(ts, type=pa.timestamp(unit))
         for fmt in formats:
-            with pytest.raises(pa.ArrowInvalid, match="Timestamp without a "
-                                                      "time zone cannot be "
-                                                      "reliably printed."):
+            with pytest.raises(pa.ArrowInvalid,
+                               match="Timestamps without a time zone "
+                                     "cannot be reliably formatted"):
                 pc.strftime(tsa, options=pc.StrftimeOptions(fmt))
 
 

From 2ab5b5c0ef663b6d4cb434703f611adc8340f4e3 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Wed, 18 Aug 2021 16:39:50 +0200
Subject: [PATCH 10/10] Fix std::locale construction

---
 cpp/src/arrow/compute/kernels/scalar_temporal.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index 552484deb6f..32e92ea0d08 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -91,7 +91,7 @@ Result<const time_zone*> LocateZone(const std::string& timezone) {
 
 Result<std::locale> GetLocale(const std::string& locale) {
   try {
-    return std::locale(locale);
+    return std::locale(locale.c_str());
   } catch (const std::runtime_error& ex) {
     return Status::Invalid("Cannot find locale '", locale, "': ", ex.what());
   }