From 7c05a64b61f178b10394db1280d99610ddddf229 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Thu, 24 Jun 2021 23:56:40 +0200
Subject: [PATCH 01/15] Adding TemporalOptions.

---
 .../arrow/compute/kernels/scalar_temporal.cc  | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index 1694d22ffae..0a8591cae79 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -35,6 +35,7 @@ using arrow_vendored::date::days;
 using arrow_vendored::date::floor;
 using arrow_vendored::date::hh_mm_ss;
 using arrow_vendored::date::sys_time;
+using arrow_vendored::date::time_zone;
 using arrow_vendored::date::trunc;
 using arrow_vendored::date::weekday;
 using arrow_vendored::date::weeks;
@@ -80,6 +81,39 @@ struct TemporalComponentExtract {
   }
 };
 
+/// \addtogroup compute-concrete-options
+/// @{
+
+/// \brief Control behavior of temporal kernels
+///
+/// Used to control timestamp localization and handling ambiguous/nonexistent times.
+struct ARROW_EXPORT TemporalOptions : public FunctionOptions {
+  /// How to interpret ambiguous local times that can be interpreted as
+  /// multiple instants due to DST shifts.
+  enum Ambiguous { RAISE_AMBIGUOUS = 0, INFER, IGNORE_AMBIGUOUS };
+
+  /// How to handle local times that do not exists due to DST shifts.
+  enum Nonexistent {
+    RAISE_NONEXISTENT = 0,
+    SHIFT_FORWARD,
+    SHIFT_BACKWARD,
+    IGNORE_NONEXISTENT
+  };
+
+  explicit TemporalOptions(const int64_t index_of_monday = 1,
+                           const time_zone* tz = nullptr,
+                           const Ambiguous ambiguous = RAISE_AMBIGUOUS,
+                           const Nonexistent nonexistent = RAISE_NONEXISTENT)
+      : tz(tz), ambiguous(ambiguous), nonexistent(nonexistent) {}
+
+  static TemporalOptions Defaults() { return TemporalOptions{}; }
+
+  const int64_t index_of_monday = 0;
+  const time_zone* tz;
+  const enum Ambiguous ambiguous;
+  const enum Nonexistent nonexistent;
+};
+
 // ----------------------------------------------------------------------
 // Extract year from timestamp
 

From 4bc1fdc13d4e6f41b341d17cf12b52234a054d09 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Mon, 28 Jun 2021 17:01:00 +0200
Subject: [PATCH 02/15] Renaming to TemporalComponentExtractionOptions.

---
 cpp/src/arrow/compute/api_scalar.cc           |   6 +-
 cpp/src/arrow/compute/api_scalar.h            |  17 ++-
 .../arrow/compute/kernels/scalar_temporal.cc  | 106 ++++++++++++------
 .../compute/kernels/scalar_temporal_test.cc   |   7 ++
 docs/source/cpp/compute.rst                   |  73 ++++++------
 5 files changed, 135 insertions(+), 74 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index 2021c8a30c6..6f320843629 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -458,7 +458,6 @@ Result<Datum> IfElse(const Datum& cond, const Datum& if_true, const Datum& if_fa
 SCALAR_EAGER_UNARY(Year, "year")
 SCALAR_EAGER_UNARY(Month, "month")
 SCALAR_EAGER_UNARY(Day, "day")
-SCALAR_EAGER_UNARY(DayOfWeek, "day_of_week")
 SCALAR_EAGER_UNARY(DayOfYear, "day_of_year")
 SCALAR_EAGER_UNARY(ISOYear, "iso_year")
 SCALAR_EAGER_UNARY(ISOWeek, "iso_week")
@@ -472,5 +471,10 @@ SCALAR_EAGER_UNARY(Microsecond, "microsecond")
 SCALAR_EAGER_UNARY(Nanosecond, "nanosecond")
 SCALAR_EAGER_UNARY(Subsecond, "subsecond")
 
+Result<Datum> DayOfWeek(const Datum& arg, TemporalComponentExtractionOptions options,
+                        ExecContext* ctx) {
+  return CallFunction("day_of_week", {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 89b4faca940..4799ab3aa33 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -244,6 +244,18 @@ class ARROW_EXPORT ProjectOptions : public FunctionOptions {
   std::vector<std::shared_ptr<const KeyValueMetadata>> field_metadata;
 };
 
+struct ARROW_EXPORT TemporalComponentExtractionOptions : public FunctionOptions {
+  explicit TemporalComponentExtractionOptions(int64_t start_index = 0)
+      : start_index(start_index) {}
+
+  static TemporalComponentExtractionOptions Defaults() {
+    return TemporalComponentExtractionOptions{};
+  }
+
+  /// Index of the first day of the week.
+  int64_t start_index;
+};
+
 /// @}
 
 /// \brief Get the absolute value of a value. Array values can be of arbitrary
@@ -721,7 +733,10 @@ Result<Datum> Day(const Datum& values, ExecContext* ctx = NULLPTR);
 ///
 /// \since 5.0.0
 /// \note API not yet finalized
-ARROW_EXPORT Result<Datum> DayOfWeek(const Datum& values, ExecContext* ctx = NULLPTR);
+ARROW_EXPORT Result<Datum> DayOfWeek(const Datum& values,
+                                     TemporalComponentExtractionOptions options =
+                                         TemporalComponentExtractionOptions::Defaults(),
+                                     ExecContext* ctx = NULLPTR);
 
 /// \brief DayOfYear returns number of day of the year for each element of `values`.
 /// January 1st maps to day number 1, February 1st to 32, etc.
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index 0a8591cae79..935091fa8f7 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -16,6 +16,7 @@
 // under the License.
 
 #include "arrow/builder.h"
+#include "arrow/compute/api_scalar.h"
 #include "arrow/compute/kernels/common.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/time.h"
@@ -49,6 +50,8 @@ using arrow_vendored::date::literals::thu;
 using internal::applicator::ScalarUnaryNotNull;
 using internal::applicator::SimpleUnary;
 
+using TemporalComponentExtractState = OptionsWrapper<TemporalComponentExtractionOptions>;
+
 const std::string& GetInputTimezone(const Datum& datum) {
   return checked_cast<const TimestampType&>(*datum.type()).timezone();
 }
@@ -81,37 +84,18 @@ struct TemporalComponentExtract {
   }
 };
 
-/// \addtogroup compute-concrete-options
-/// @{
-
-/// \brief Control behavior of temporal kernels
-///
-/// Used to control timestamp localization and handling ambiguous/nonexistent times.
-struct ARROW_EXPORT TemporalOptions : public FunctionOptions {
-  /// How to interpret ambiguous local times that can be interpreted as
-  /// multiple instants due to DST shifts.
-  enum Ambiguous { RAISE_AMBIGUOUS = 0, INFER, IGNORE_AMBIGUOUS };
-
-  /// How to handle local times that do not exists due to DST shifts.
-  enum Nonexistent {
-    RAISE_NONEXISTENT = 0,
-    SHIFT_FORWARD,
-    SHIFT_BACKWARD,
-    IGNORE_NONEXISTENT
-  };
-
-  explicit TemporalOptions(const int64_t index_of_monday = 1,
-                           const time_zone* tz = nullptr,
-                           const Ambiguous ambiguous = RAISE_AMBIGUOUS,
-                           const Nonexistent nonexistent = RAISE_NONEXISTENT)
-      : tz(tz), ambiguous(ambiguous), nonexistent(nonexistent) {}
-
-  static TemporalOptions Defaults() { return TemporalOptions{}; }
-
-  const int64_t index_of_monday = 0;
-  const time_zone* tz;
-  const enum Ambiguous ambiguous;
-  const enum Nonexistent nonexistent;
+template <typename Op, typename OutType>
+struct TemporalComponentExtractWithOptions {
+  using OutValue = typename internal::GetOutputType<OutType>::T;
+
+  static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+    TemporalComponentExtractionOptions options = TemporalComponentExtractState::Get(ctx);
+
+    RETURN_NOT_OK(TemporalComponentExtractCheckTimezone(batch.values[0]));
+    applicator::ScalarUnaryNotNullStateful<OutType, TimestampType, Op> kernel{
+        Op(options)};
+    return kernel.Exec(ctx, batch, out);
+  }
 };
 
 // ----------------------------------------------------------------------
@@ -155,13 +139,16 @@ struct Day {
 
 template <typename Duration>
 struct DayOfWeek {
+  explicit DayOfWeek(TemporalComponentExtractionOptions options) : options(options) {}
+
   template <typename T, typename Arg0>
-  static T Call(KernelContext*, Arg0 arg, Status*) {
+  T Call(KernelContext*, Arg0 arg, Status*) const {
     return static_cast<T>(
         weekday(year_month_day(floor<days>(sys_time<Duration>(Duration{arg}))))
             .iso_encoding() -
-        1);
+        1 + options.start_index);
   }
+  TemporalComponentExtractionOptions options;
 };
 
 // ----------------------------------------------------------------------
@@ -432,6 +419,46 @@ std::shared_ptr<ScalarFunction> MakeTemporal(std::string name, const FunctionDoc
   return func;
 }
 
+template <template <typename...> class Op, typename OutType>
+std::shared_ptr<ScalarFunction> MakeTemporalWithOptions(
+    std::string name, const FunctionDoc* doc,
+    const TemporalComponentExtractionOptions* default_options, KernelInit init) {
+  const auto& out_type = TypeTraits<OutType>::type_singleton();
+  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 =
+            TemporalComponentExtractWithOptions<Op<std::chrono::seconds>, OutType>::Exec;
+        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+        break;
+      }
+      case TimeUnit::MILLI: {
+        auto exec = TemporalComponentExtractWithOptions<Op<std::chrono::milliseconds>,
+                                                        OutType>::Exec;
+        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+        break;
+      }
+      case TimeUnit::MICRO: {
+        auto exec = TemporalComponentExtractWithOptions<Op<std::chrono::microseconds>,
+                                                        OutType>::Exec;
+        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+        break;
+      }
+      case TimeUnit::NANO: {
+        auto exec = TemporalComponentExtractWithOptions<Op<std::chrono::nanoseconds>,
+                                                        OutType>::Exec;
+        DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
+        break;
+      }
+    }
+  }
+  return func;
+}
+
 template <template <typename...> class Op>
 std::shared_ptr<ScalarFunction> MakeStructTemporal(std::string name,
                                                    const FunctionDoc* doc) {
@@ -486,8 +513,11 @@ const FunctionDoc day_doc{
 const FunctionDoc day_of_week_doc{
     "Extract day of the week number",
     ("Week starts on Monday denoted by 0 and ends on Sunday denoted by 6.\n"
-     "Returns an error if timestamp has a defined timezone. Null values return null."),
-    {"values"}};
+     "Returns an error if timestamp has a defined timezone. Null values return null.\n"
+     "TemporalComponentExtractionOptions.start_index can optionally be used to set the "
+     "index of the day that starts the week."),
+    {"values"},
+    "TemporalComponentExtractionOptions"};
 
 const FunctionDoc day_of_year_doc{
     "Extract number of day of year",
@@ -571,7 +601,11 @@ void RegisterScalarTemporal(FunctionRegistry* registry) {
   auto day = MakeTemporal<Day, Int64Type>("day", &year_doc);
   DCHECK_OK(registry->AddFunction(std::move(day)));
 
-  auto day_of_week = MakeTemporal<DayOfWeek, Int64Type>("day_of_week", &day_of_week_doc);
+  static auto default_temporal_component_extraction_options =
+      TemporalComponentExtractionOptions::Defaults();
+  auto day_of_week = MakeTemporalWithOptions<DayOfWeek, Int64Type>(
+      "day_of_week", &day_of_week_doc, &default_temporal_component_extraction_options,
+      TemporalComponentExtractState::Init);
   DCHECK_OK(registry->AddFunction(std::move(day_of_week)));
 
   auto day_of_year = MakeTemporal<DayOfYear, Int64Type>("day_of_year", &day_of_year_doc);
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
index cc01d25de7c..f686c134ded 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
@@ -50,6 +50,7 @@ TEST(ScalarTemporalTest, TestTemporalComponentExtraction) {
   auto month = "[1, 2, 1, 5, null, 1, 12, 12, 12, 1, 1, 1, 1, 12, 12, 12, 1]";
   auto day = "[1, 29, 1, 18, null, 1, 31, 30, 31, 1, 3, 4, 1, 31, 28, 29, 1]";
   auto day_of_week = "[3, 1, 6, 2, null, 2, 1, 0, 3, 4, 6, 0, 6, 5, 6, 0, 6]";
+  auto day_of_week_monday_1 = "[4, 2, 7, 3, null, 3, 2, 1, 4, 5, 7, 1, 7, 6, 7, 1, 7]";
   auto day_of_year =
       "[1, 60, 1, 138, null, 1, 365, 364, 365, 1, 3, 4, 1, 365, 363, 364, 1]";
   auto iso_year =
@@ -102,6 +103,12 @@ TEST(ScalarTemporalTest, TestTemporalComponentExtraction) {
   CheckScalarUnary("microsecond", unit, times, int64(), microsecond);
   CheckScalarUnary("nanosecond", unit, times, int64(), nanosecond);
   CheckScalarUnary("subsecond", unit, times, float64(), subsecond);
+
+  auto timestamps = ArrayFromJSON(unit, times);
+  auto expected = ArrayFromJSON(int64(), day_of_week_monday_1);
+  const auto monday_1_options = TemporalComponentExtractionOptions(/*start_index=*/1);
+  ASSERT_OK_AND_ASSIGN(Datum result, DayOfWeek(timestamps, monday_1_options));
+  ASSERT_TRUE(result.Equals(expected));
 }
 
 TEST(ScalarTemporalTest, TestTemporalComponentExtractionWithDifferentUnits) {
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 2d41c579747..8c3d804df32 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -988,44 +988,45 @@ Temporal component extraction
 These functions extract datetime components (year, month, day, etc) from timestamp type.
 Note: this is currently not supported for timestamps with timezone information.
 
-+--------------------+------------+-------------------+---------------+--------+
-| Function name      | Arity      | Input types       | Output type   | Notes  |
-+====================+============+===================+===============+========+
-| year               | Unary      | Temporal          | Int64         |        |
-+--------------------+------------+-------------------+---------------+--------+
-| month              | Unary      | Temporal          | Int64         |        |
-+--------------------+------------+-------------------+---------------+--------+
-| day                | Unary      | Temporal          | Int64         |        |
-+--------------------+------------+-------------------+---------------+--------+
-| day_of_week        | Unary      | Temporal          | Int64         | \(1)   |
-+--------------------+------------+-------------------+---------------+--------+
-| day_of_year        | Unary      | Temporal          | Int64         |        |
-+--------------------+------------+-------------------+---------------+--------+
-| iso_year           | Unary      | Temporal          | Int64         | \(2)   |
-+--------------------+------------+-------------------+---------------+--------+
-| iso_week           | Unary      | Temporal          | Int64         | \(2)   |
-+--------------------+------------+-------------------+---------------+--------+
-| iso_calendar       | Unary      | Temporal          | Struct        | \(3)   |
-+--------------------+------------+-------------------+---------------+--------+
-| quarter            | Unary      | Temporal          | Int64         |        |
-+--------------------+------------+-------------------+---------------+--------+
-| hour               | Unary      | Temporal          | Int64         |        |
-+--------------------+------------+-------------------+---------------+--------+
-| minute             | Unary      | Temporal          | Int64         |        |
-+--------------------+------------+-------------------+---------------+--------+
-| second             | Unary      | Temporal          | Int64         |        |
-+--------------------+------------+-------------------+---------------+--------+
-| millisecond        | Unary      | Temporal          | Int64         |        |
-+--------------------+------------+-------------------+---------------+--------+
-| microsecond        | Unary      | Temporal          | Int64         |        |
-+--------------------+------------+-------------------+---------------+--------+
-| nanosecond         | Unary      | Temporal          | Int64         |        |
-+--------------------+------------+-------------------+---------------+--------+
-| subsecond          | Unary      | Temporal          | Double        |        |
-+--------------------+------------+-------------------+---------------+--------+
++--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
+| Function name      | Arity      | Input types       | Output type   | Notes  | Options class                                |
++====================+============+===================+===============+========+==============================================+
+| year               | Unary      | Temporal          | Int64         |        |                                              |
++--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
+| month              | Unary      | Temporal          | Int64         |        |                                              |
++--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
+| day                | Unary      | Temporal          | Int64         |        |                                              |
++--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
+| day_of_week        | Unary      | Temporal          | Int64         | \(1)   | :struct:`TemporalComponentExtractionOptions` |
++--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
+| day_of_year        | Unary      | Temporal          | Int64         |        |                                              |
++--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
+| iso_year           | Unary      | Temporal          | Int64         | \(2)   |                                              |
++--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
+| iso_week           | Unary      | Temporal          | Int64         | \(2)   |                                              |
++--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
+| iso_calendar       | Unary      | Temporal          | Struct        | \(3)   |                                              |
++--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
+| quarter            | Unary      | Temporal          | Int64         |        |                                              |
++--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
+| hour               | Unary      | Temporal          | Int64         |        |                                              |
++--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
+| minute             | Unary      | Temporal          | Int64         |        |                                              |
++--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
+| second             | Unary      | Temporal          | Int64         |        |                                              |
++--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
+| millisecond        | Unary      | Temporal          | Int64         |        |                                              |
++--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
+| microsecond        | Unary      | Temporal          | Int64         |        |                                              |
++--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
+| nanosecond         | Unary      | Temporal          | Int64         |        |                                              |
++--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
+| subsecond          | Unary      | Temporal          | Double        |        |                                              |
++--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
 
 * \(1) Outputs the number of the day of the week. Week begins on Monday and is denoted
-  by 0 and ends on Sunday denoted by 6.
+  by 0 and ends on Sunday denoted by 6. :struct:`TemporalComponentExtractionOptions`
+  can be used to set the index of the day that starts the week.
 * \(2) First ISO week has the majority (4 or more) of it's days in January. ISO year
   starts with the first ISO week.
   See `ISO 8601 week date definition`_ for more details.

From f70bd88bd5971825b3d3f71c8413e94b7298b425 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Tue, 29 Jun 2021 03:52:13 +0200
Subject: [PATCH 03/15] Adding TemporalComponentExtractionOptions to R.

---
 cpp/src/arrow/compute/api_scalar.h               | 6 +++---
 cpp/src/arrow/compute/kernels/scalar_temporal.cc | 4 ++--
 r/R/dplyr-functions.R                            | 2 +-
 r/src/compute.cpp                                | 5 +++++
 4 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 4799ab3aa33..5352e76460a 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -245,15 +245,15 @@ class ARROW_EXPORT ProjectOptions : public FunctionOptions {
 };
 
 struct ARROW_EXPORT TemporalComponentExtractionOptions : public FunctionOptions {
-  explicit TemporalComponentExtractionOptions(int64_t start_index = 0)
-      : start_index(start_index) {}
+  explicit TemporalComponentExtractionOptions(int64_t week_start = 0)
+      : week_start(std::move(week_start)) {}
 
   static TemporalComponentExtractionOptions Defaults() {
     return TemporalComponentExtractionOptions{};
   }
 
   /// Index of the first day of the week.
-  int64_t start_index;
+  int64_t week_start;
 };
 
 /// @}
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index 935091fa8f7..92ffd4f3e00 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -146,7 +146,7 @@ struct DayOfWeek {
     return static_cast<T>(
         weekday(year_month_day(floor<days>(sys_time<Duration>(Duration{arg}))))
             .iso_encoding() -
-        1 + options.start_index);
+        1 + options.week_start);
   }
   TemporalComponentExtractionOptions options;
 };
@@ -514,7 +514,7 @@ const FunctionDoc day_of_week_doc{
     "Extract day of the week number",
     ("Week starts on Monday denoted by 0 and ends on Sunday denoted by 6.\n"
      "Returns an error if timestamp has a defined timezone. Null values return null.\n"
-     "TemporalComponentExtractionOptions.start_index can optionally be used to set the "
+     "TemporalComponentExtractionOptions.week_start can optionally be used to set the "
      "index of the day that starts the week."),
     {"values"},
     "TemporalComponentExtractionOptions"};
diff --git a/r/R/dplyr-functions.R b/r/R/dplyr-functions.R
index 27d6e889199..6c890f815af 100644
--- a/r/R/dplyr-functions.R
+++ b/r/R/dplyr-functions.R
@@ -545,6 +545,6 @@ nse_funcs$wday <- function(x, label = FALSE, abbr = TRUE, week_start = getOption
 
   # overall formula to convert from arrow::wday to lubridate::wday is:
   #  ((wday(day) - start + 8) %% 7) + 1
-  ((Expression$create("day_of_week", x) - Expression$scalar(week_start) + 8) %% 7) + 1
+  ((Expression$create("day_of_week", x, options = list(week_start = 1)) - Expression$scalar(week_start) + 8) %% 7) + 1
 
 }
diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index 458e0e386e9..98eb9fee1b8 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -264,6 +264,11 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
                                      max_replacements);
   }
 
+  if (func_name == "day_of_week") {
+    using Options = arrow::compute::TemporalComponentExtractionOptions;
+    return std::make_shared<Options>(cpp11::as_cpp<int64_t>(options["week_start"]));
+  }
+
   if (func_name == "strptime") {
     using Options = arrow::compute::StrptimeOptions;
     return std::make_shared<Options>(

From e3750fcd32c4ce33eeb8f1b22873941804a08772 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Wed, 30 Jun 2021 04:48:02 +0200
Subject: [PATCH 04/15] Refactoring.

---
 cpp/src/arrow/compute/api_scalar.h            | 17 +++++---
 .../arrow/compute/kernels/scalar_temporal.cc  | 22 ++++++----
 .../compute/kernels/scalar_temporal_test.cc   | 41 ++++++++++++++++---
 docs/source/cpp/compute.rst                   |  7 ++--
 r/R/dplyr-functions.R                         | 12 +-----
 r/src/compute.cpp                             |  3 +-
 6 files changed, 70 insertions(+), 32 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 5352e76460a..4cdd3f011cf 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -245,15 +245,19 @@ class ARROW_EXPORT ProjectOptions : public FunctionOptions {
 };
 
 struct ARROW_EXPORT TemporalComponentExtractionOptions : public FunctionOptions {
-  explicit TemporalComponentExtractionOptions(int64_t week_start = 0)
-      : week_start(std::move(week_start)) {}
+  explicit TemporalComponentExtractionOptions(bool one_based_numbering = false,
+                                              uint32_t week_start = 1)
+      : one_based_numbering(std::move(one_based_numbering)),
+        week_start(std::move(week_start)) {}
 
   static TemporalComponentExtractionOptions Defaults() {
     return TemporalComponentExtractionOptions{};
   }
 
-  /// Index of the first day of the week.
-  int64_t week_start;
+  /// Number days from 1 if true and form 0 if false
+  bool one_based_numbering;
+  /// What day does the week start with (Monday=1, Sunday=7)
+  uint32_t week_start;
 };
 
 /// @}
@@ -725,9 +729,12 @@ ARROW_EXPORT
 Result<Datum> Day(const Datum& values, ExecContext* ctx = NULLPTR);
 
 /// \brief DayOfWeek returns number of the day of the week value for each element of
-/// `values`. Week starts on Monday denoted by 0 and ends on Sunday denoted by 6.
+/// `values`. By default week starts on Monday denoted by 0 and ends on Sunday denoted
+/// by 6. Start day of the week (Monday=1, Sunday=7) and numbering base (0 or 1) can be
+/// set using TemporalComponentExtractionOptions
 ///
 /// \param[in] values input to extract number of the day of the week from
+/// \param[in] options for setting start of the week and day numbering
 /// \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 92ffd4f3e00..82f8e7d4015 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -136,6 +136,10 @@ struct Day {
 
 // ----------------------------------------------------------------------
 // Extract day of week from timestamp
+//
+// By default week starts on Monday represented by 0 and ends on Sunday represented
+// by 6. Start day of the week (Monday=1, Sunday=7) and numbering start (0 or 1) can be
+// set using TemporalComponentExtractionOptions
 
 template <typename Duration>
 struct DayOfWeek {
@@ -143,11 +147,13 @@ struct DayOfWeek {
 
   template <typename T, typename Arg0>
   T Call(KernelContext*, Arg0 arg, Status*) const {
-    return static_cast<T>(
-        weekday(year_month_day(floor<days>(sys_time<Duration>(Duration{arg}))))
-            .iso_encoding() -
-        1 + options.week_start);
+    auto wd = arrow_vendored::date::year_month_weekday(
+                  floor<days>(sys_time<Duration>(Duration{arg})))
+                  .weekday()
+                  .iso_encoding();
+    return (wd + 7 - options.week_start) % 7 + options.one_based_numbering;
   }
+
   TemporalComponentExtractionOptions options;
 };
 
@@ -512,10 +518,12 @@ const FunctionDoc day_doc{
 
 const FunctionDoc day_of_week_doc{
     "Extract day of the week number",
-    ("Week starts on Monday denoted by 0 and ends on Sunday denoted by 6.\n"
+    ("By default Week starts on Monday represented by 0 and ends on Sunday represented "
+     "by 6.\n"
      "Returns an error if timestamp has a defined timezone. Null values return null.\n"
-     "TemporalComponentExtractionOptions.week_start can optionally be used to set the "
-     "index of the day that starts the week."),
+     "TemporalComponentExtractionOptions.week_start can be used to set another starting "
+     "day using ISO convention (Monday=1, Sunday=7). Day numbering can start with 0 or "
+     "1 using TemporalComponentExtractionOptions.one_based_numbering parameter."),
     {"values"},
     "TemporalComponentExtractionOptions"};
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
index f686c134ded..31e57e2a125 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
@@ -50,7 +50,6 @@ TEST(ScalarTemporalTest, TestTemporalComponentExtraction) {
   auto month = "[1, 2, 1, 5, null, 1, 12, 12, 12, 1, 1, 1, 1, 12, 12, 12, 1]";
   auto day = "[1, 29, 1, 18, null, 1, 31, 30, 31, 1, 3, 4, 1, 31, 28, 29, 1]";
   auto day_of_week = "[3, 1, 6, 2, null, 2, 1, 0, 3, 4, 6, 0, 6, 5, 6, 0, 6]";
-  auto day_of_week_monday_1 = "[4, 2, 7, 3, null, 3, 2, 1, 4, 5, 7, 1, 7, 6, 7, 1, 7]";
   auto day_of_year =
       "[1, 60, 1, 138, null, 1, 365, 364, 365, 1, 3, 4, 1, 365, 363, 364, 1]";
   auto iso_year =
@@ -105,10 +104,42 @@ TEST(ScalarTemporalTest, TestTemporalComponentExtraction) {
   CheckScalarUnary("subsecond", unit, times, float64(), subsecond);
 
   auto timestamps = ArrayFromJSON(unit, times);
-  auto expected = ArrayFromJSON(int64(), day_of_week_monday_1);
-  const auto monday_1_options = TemporalComponentExtractionOptions(/*start_index=*/1);
-  ASSERT_OK_AND_ASSIGN(Datum result, DayOfWeek(timestamps, monday_1_options));
-  ASSERT_TRUE(result.Equals(expected));
+  auto day_of_week_week_start_7_zero_based =
+      "[4, 2, 0, 3, null, 3, 2, 1, 4, 5, 0, 1, 0, 6, 0, 1, 0]";
+  auto day_of_week_week_start_2_zero_based =
+      "[2, 0, 5, 1, null, 1, 0, 6, 2, 3, 5, 6, 5, 4, 5, 6, 5]";
+  auto day_of_week_week_start_7_one_based =
+      "[5, 3, 1, 4, null, 4, 3, 2, 5, 6, 1, 2, 1, 7, 1, 2, 1]";
+  auto day_of_week_week_start_2_one_based =
+      "[3, 1, 6, 2, null, 2, 1, 7, 3, 4, 6, 7, 6, 5, 6, 7, 6]";
+
+  auto expected_70 = ArrayFromJSON(int64(), day_of_week_week_start_7_zero_based);
+  ASSERT_OK_AND_ASSIGN(
+      Datum result_70,
+      DayOfWeek(timestamps, TemporalComponentExtractionOptions(
+                                /*one_based_numbering=*/false, /*week_start=*/7)));
+  ASSERT_TRUE(result_70.Equals(expected_70));
+
+  auto expected_20 = ArrayFromJSON(int64(), day_of_week_week_start_2_zero_based);
+  ASSERT_OK_AND_ASSIGN(
+      Datum result_20,
+      DayOfWeek(timestamps, TemporalComponentExtractionOptions(
+                                /*one_based_numbering=*/false, /*week_start=*/2)));
+  ASSERT_TRUE(result_20.Equals(expected_20));
+
+  auto expected_71 = ArrayFromJSON(int64(), day_of_week_week_start_7_one_based);
+  ASSERT_OK_AND_ASSIGN(
+      Datum result_71,
+      DayOfWeek(timestamps, TemporalComponentExtractionOptions(
+                                /*one_based_numbering=*/true, /*week_start=*/7)));
+  ASSERT_TRUE(result_71.Equals(expected_71));
+
+  auto expected_21 = ArrayFromJSON(int64(), day_of_week_week_start_2_one_based);
+  ASSERT_OK_AND_ASSIGN(
+      Datum result_21,
+      DayOfWeek(timestamps, TemporalComponentExtractionOptions(
+                                /*one_based_numbering=*/true, /*week_start=*/2)));
+  ASSERT_TRUE(result_21.Equals(expected_21));
 }
 
 TEST(ScalarTemporalTest, TestTemporalComponentExtractionWithDifferentUnits) {
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 8c3d804df32..edb8b8592ac 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1024,9 +1024,10 @@ Note: this is currently not supported for timestamps with timezone information.
 | subsecond          | Unary      | Temporal          | Double        |        |                                              |
 +--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
 
-* \(1) Outputs the number of the day of the week. Week begins on Monday and is denoted
-  by 0 and ends on Sunday denoted by 6. :struct:`TemporalComponentExtractionOptions`
-  can be used to set the index of the day that starts the week.
+* \(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:`TemporalComponentExtractionOptions::week_start`
+  can be used to set the starting day of the week using ISO convention (Monday=1, Sunday=7). Day numbering can
+  start with 0 or 1 using :member:`TemporalComponentExtractionOptions::week_start` paramter.
 * \(2) First ISO week has the majority (4 or more) of it's days in January. ISO year
   starts with the first ISO week.
   See `ISO 8601 week date definition`_ for more details.
diff --git a/r/R/dplyr-functions.R b/r/R/dplyr-functions.R
index 6c890f815af..055cff5472b 100644
--- a/r/R/dplyr-functions.R
+++ b/r/R/dplyr-functions.R
@@ -526,14 +526,6 @@ nse_funcs$second <- function(x) {
   Expression$create("add", Expression$create("second", x), Expression$create("subsecond", x))
 }
 
-# After ARROW-13054 is completed, we can refactor this for simplicity
-#
-# Arrow's `day_of_week` kernel counts from 0 (Monday) to 6 (Sunday), whereas
-# `lubridate::wday` counts from 1 to 7, and allows users to specify which day
-# of the week is first (Sunday by default).  This Expression converts the returned
-# day of the week back to the value that would be returned by lubridate by
-# providing offset values based on the specified week_start day, and adding 1
-# so the returned value is 1-indexed instead of 0-indexed.
 nse_funcs$wday <- function(x, label = FALSE, abbr = TRUE, week_start = getOption("lubridate.week.start", 7)) {
 
   # The "day_of_week" compute function returns numeric days of week and not locale-aware strftime
@@ -543,8 +535,6 @@ nse_funcs$wday <- function(x, label = FALSE, abbr = TRUE, week_start = getOption
     arrow_not_supported("Label argument")
   }
 
-  # overall formula to convert from arrow::wday to lubridate::wday is:
-  #  ((wday(day) - start + 8) %% 7) + 1
-  ((Expression$create("day_of_week", x, options = list(week_start = 1)) - Expression$scalar(week_start) + 8) %% 7) + 1
+  Expression$create("day_of_week", x, options = list(one_based_numbering = TRUE, week_start = week_start))
 
 }
diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index 98eb9fee1b8..94e0a7105bc 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -266,7 +266,8 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
 
   if (func_name == "day_of_week") {
     using Options = arrow::compute::TemporalComponentExtractionOptions;
-    return std::make_shared<Options>(cpp11::as_cpp<int64_t>(options["week_start"]));
+    return std::make_shared<Options>(cpp11::as_cpp<bool>(options["one_based_numbering"]),
+                                     cpp11::as_cpp<uint32_t>(options["week_start"]));
   }
 
   if (func_name == "strptime") {

From f46f9691186722c28c05caca769df898179f1030 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Wed, 30 Jun 2021 14:50:55 +0200
Subject: [PATCH 05/15] Default options for day_of_week.

---
 r/src/compute.cpp | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index 94e0a7105bc..4e1142396cf 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -266,8 +266,14 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
 
   if (func_name == "day_of_week") {
     using Options = arrow::compute::TemporalComponentExtractionOptions;
-    return std::make_shared<Options>(cpp11::as_cpp<bool>(options["one_based_numbering"]),
-                                     cpp11::as_cpp<uint32_t>(options["week_start"]));
+    auto out = std::make_shared<Options>(Options::Defaults());
+    if (!Rf_isNull(options["one_based_numbering"])) {
+      out->null_replacement = cpp11::as_cpp<bool>(options["one_based_numbering"]);
+    }
+    if (!Rf_isNull(options["week_start"])) {
+      out->null_replacement = cpp11::as_cpp<uint32_t>(options["week_start"]);
+    }
+    return out;
   }
 
   if (func_name == "strptime") {

From d610f74e9f263d3533b7a42c2d258db9a38d8456 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Wed, 30 Jun 2021 15:33:27 +0200
Subject: [PATCH 06/15] Semi-default TemporalComponentExtractionOptions for R.

---
 r/src/compute.cpp | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index 4e1142396cf..39f7359d29f 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -266,14 +266,9 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
 
   if (func_name == "day_of_week") {
     using Options = arrow::compute::TemporalComponentExtractionOptions;
-    auto out = std::make_shared<Options>(Options::Defaults());
-    if (!Rf_isNull(options["one_based_numbering"])) {
-      out->null_replacement = cpp11::as_cpp<bool>(options["one_based_numbering"]);
-    }
-    if (!Rf_isNull(options["week_start"])) {
-      out->null_replacement = cpp11::as_cpp<uint32_t>(options["week_start"]);
-    }
-    return out;
+    bool one_based_numbering = true;
+    return std::make_shared<Options>(one_based_numbering,
+                                     cpp11::as_cpp<uint32_t>(options["week_start"]));
   }
 
   if (func_name == "strptime") {

From 93ed62900fb261fc72a2e58c526bb278cc2ef393 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Wed, 30 Jun 2021 17:10:13 +0200
Subject: [PATCH 07/15] TemporalComponentExtractionOptions to DayOfWeekOptions

---
 cpp/src/arrow/compute/api_scalar.cc           |  3 +-
 cpp/src/arrow/compute/api_scalar.h            | 18 ++---
 .../arrow/compute/kernels/scalar_temporal.cc  | 46 ++++++-----
 .../compute/kernels/scalar_temporal_test.cc   |  8 +-
 docs/source/cpp/compute.rst                   | 76 +++++++++----------
 5 files changed, 72 insertions(+), 79 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index 6f320843629..5628b223850 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -471,8 +471,7 @@ SCALAR_EAGER_UNARY(Microsecond, "microsecond")
 SCALAR_EAGER_UNARY(Nanosecond, "nanosecond")
 SCALAR_EAGER_UNARY(Subsecond, "subsecond")
 
-Result<Datum> DayOfWeek(const Datum& arg, TemporalComponentExtractionOptions options,
-                        ExecContext* ctx) {
+Result<Datum> DayOfWeek(const Datum& arg, DayOfWeekOptions options, ExecContext* ctx) {
   return CallFunction("day_of_week", {arg}, &options, ctx);
 }
 
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 4cdd3f011cf..e79f2bd74bf 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -244,15 +244,12 @@ class ARROW_EXPORT ProjectOptions : public FunctionOptions {
   std::vector<std::shared_ptr<const KeyValueMetadata>> field_metadata;
 };
 
-struct ARROW_EXPORT TemporalComponentExtractionOptions : public FunctionOptions {
-  explicit TemporalComponentExtractionOptions(bool one_based_numbering = false,
-                                              uint32_t week_start = 1)
+struct ARROW_EXPORT DayOfWeekOptions : public FunctionOptions {
+  explicit DayOfWeekOptions(bool one_based_numbering = false, uint32_t week_start = 1)
       : one_based_numbering(std::move(one_based_numbering)),
         week_start(std::move(week_start)) {}
 
-  static TemporalComponentExtractionOptions Defaults() {
-    return TemporalComponentExtractionOptions{};
-  }
+  static DayOfWeekOptions Defaults() { return DayOfWeekOptions{}; }
 
   /// Number days from 1 if true and form 0 if false
   bool one_based_numbering;
@@ -731,7 +728,7 @@ Result<Datum> Day(const Datum& values, ExecContext* ctx = NULLPTR);
 /// \brief DayOfWeek returns number of the day of the week value for each element of
 /// `values`. By default week starts on Monday denoted by 0 and ends on Sunday denoted
 /// by 6. Start day of the week (Monday=1, Sunday=7) and numbering base (0 or 1) can be
-/// set using TemporalComponentExtractionOptions
+/// set using DayOfWeekOptions
 ///
 /// \param[in] values input to extract number of the day of the week from
 /// \param[in] options for setting start of the week and day numbering
@@ -740,10 +737,9 @@ Result<Datum> Day(const Datum& values, ExecContext* ctx = NULLPTR);
 ///
 /// \since 5.0.0
 /// \note API not yet finalized
-ARROW_EXPORT Result<Datum> DayOfWeek(const Datum& values,
-                                     TemporalComponentExtractionOptions options =
-                                         TemporalComponentExtractionOptions::Defaults(),
-                                     ExecContext* ctx = NULLPTR);
+ARROW_EXPORT Result<Datum> DayOfWeek(
+    const Datum& values, DayOfWeekOptions options = DayOfWeekOptions::Defaults(),
+    ExecContext* ctx = NULLPTR);
 
 /// \brief DayOfYear returns number of day of the year for each element of `values`.
 /// January 1st maps to day number 1, February 1st to 32, etc.
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index 82f8e7d4015..08b067a31da 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -50,7 +50,7 @@ using arrow_vendored::date::literals::thu;
 using internal::applicator::ScalarUnaryNotNull;
 using internal::applicator::SimpleUnary;
 
-using TemporalComponentExtractState = OptionsWrapper<TemporalComponentExtractionOptions>;
+using DayOfWeekState = OptionsWrapper<DayOfWeekOptions>;
 
 const std::string& GetInputTimezone(const Datum& datum) {
   return checked_cast<const TimestampType&>(*datum.type()).timezone();
@@ -85,11 +85,11 @@ struct TemporalComponentExtract {
 };
 
 template <typename Op, typename OutType>
-struct TemporalComponentExtractWithOptions {
+struct DayOfWeekOptionsWithOptions {
   using OutValue = typename internal::GetOutputType<OutType>::T;
 
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-    TemporalComponentExtractionOptions options = TemporalComponentExtractState::Get(ctx);
+    DayOfWeekOptions options = DayOfWeekState::Get(ctx);
 
     RETURN_NOT_OK(TemporalComponentExtractCheckTimezone(batch.values[0]));
     applicator::ScalarUnaryNotNullStateful<OutType, TimestampType, Op> kernel{
@@ -139,11 +139,11 @@ struct Day {
 //
 // By default week starts on Monday represented by 0 and ends on Sunday represented
 // by 6. Start day of the week (Monday=1, Sunday=7) and numbering start (0 or 1) can be
-// set using TemporalComponentExtractionOptions
+// set using DayOfWeekOptions
 
 template <typename Duration>
 struct DayOfWeek {
-  explicit DayOfWeek(TemporalComponentExtractionOptions options) : options(options) {}
+  explicit DayOfWeek(DayOfWeekOptions options) : options(options) {}
 
   template <typename T, typename Arg0>
   T Call(KernelContext*, Arg0 arg, Status*) const {
@@ -154,7 +154,7 @@ struct DayOfWeek {
     return (wd + 7 - options.week_start) % 7 + options.one_based_numbering;
   }
 
-  TemporalComponentExtractionOptions options;
+  DayOfWeekOptions options;
 };
 
 // ----------------------------------------------------------------------
@@ -427,8 +427,8 @@ std::shared_ptr<ScalarFunction> MakeTemporal(std::string name, const FunctionDoc
 
 template <template <typename...> class Op, typename OutType>
 std::shared_ptr<ScalarFunction> MakeTemporalWithOptions(
-    std::string name, const FunctionDoc* doc,
-    const TemporalComponentExtractionOptions* default_options, KernelInit init) {
+    std::string name, const FunctionDoc* doc, const DayOfWeekOptions* default_options,
+    KernelInit init) {
   const auto& out_type = TypeTraits<OutType>::type_singleton();
   auto func =
       std::make_shared<ScalarFunction>(name, Arity::Unary(), doc, default_options);
@@ -437,26 +437,25 @@ std::shared_ptr<ScalarFunction> MakeTemporalWithOptions(
     InputType in_type{match::TimestampTypeUnit(unit)};
     switch (unit) {
       case TimeUnit::SECOND: {
-        auto exec =
-            TemporalComponentExtractWithOptions<Op<std::chrono::seconds>, OutType>::Exec;
+        auto exec = DayOfWeekOptionsWithOptions<Op<std::chrono::seconds>, OutType>::Exec;
         DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
         break;
       }
       case TimeUnit::MILLI: {
-        auto exec = TemporalComponentExtractWithOptions<Op<std::chrono::milliseconds>,
-                                                        OutType>::Exec;
+        auto exec =
+            DayOfWeekOptionsWithOptions<Op<std::chrono::milliseconds>, OutType>::Exec;
         DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
         break;
       }
       case TimeUnit::MICRO: {
-        auto exec = TemporalComponentExtractWithOptions<Op<std::chrono::microseconds>,
-                                                        OutType>::Exec;
+        auto exec =
+            DayOfWeekOptionsWithOptions<Op<std::chrono::microseconds>, OutType>::Exec;
         DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
         break;
       }
       case TimeUnit::NANO: {
-        auto exec = TemporalComponentExtractWithOptions<Op<std::chrono::nanoseconds>,
-                                                        OutType>::Exec;
+        auto exec =
+            DayOfWeekOptionsWithOptions<Op<std::chrono::nanoseconds>, OutType>::Exec;
         DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
         break;
       }
@@ -521,11 +520,11 @@ const FunctionDoc day_of_week_doc{
     ("By default Week starts on Monday represented by 0 and ends on Sunday represented "
      "by 6.\n"
      "Returns an error if timestamp has a defined timezone. Null values return null.\n"
-     "TemporalComponentExtractionOptions.week_start can be used to set another starting "
-     "day using ISO convention (Monday=1, Sunday=7). Day numbering can start with 0 or "
-     "1 using TemporalComponentExtractionOptions.one_based_numbering parameter."),
+     "DayOfWeekOptions.week_start can be used to set another starting day using ISO "
+     "convention (Monday=1, Sunday=7). Day numbering can start with 0 or 1 using "
+     "DayOfWeekOptions.one_based_numbering parameter."),
     {"values"},
-    "TemporalComponentExtractionOptions"};
+    "DayOfWeekOptions"};
 
 const FunctionDoc day_of_year_doc{
     "Extract number of day of year",
@@ -609,11 +608,10 @@ void RegisterScalarTemporal(FunctionRegistry* registry) {
   auto day = MakeTemporal<Day, Int64Type>("day", &year_doc);
   DCHECK_OK(registry->AddFunction(std::move(day)));
 
-  static auto default_temporal_component_extraction_options =
-      TemporalComponentExtractionOptions::Defaults();
+  static auto default_day_of_week_options = DayOfWeekOptions::Defaults();
   auto day_of_week = MakeTemporalWithOptions<DayOfWeek, Int64Type>(
-      "day_of_week", &day_of_week_doc, &default_temporal_component_extraction_options,
-      TemporalComponentExtractState::Init);
+      "day_of_week", &day_of_week_doc, &default_day_of_week_options,
+      DayOfWeekState::Init);
   DCHECK_OK(registry->AddFunction(std::move(day_of_week)));
 
   auto day_of_year = MakeTemporal<DayOfYear, Int64Type>("day_of_year", &day_of_year_doc);
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
index 31e57e2a125..c3315e0a7d1 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
@@ -116,28 +116,28 @@ TEST(ScalarTemporalTest, TestTemporalComponentExtraction) {
   auto expected_70 = ArrayFromJSON(int64(), day_of_week_week_start_7_zero_based);
   ASSERT_OK_AND_ASSIGN(
       Datum result_70,
-      DayOfWeek(timestamps, TemporalComponentExtractionOptions(
+      DayOfWeek(timestamps, DayOfWeekOptions(
                                 /*one_based_numbering=*/false, /*week_start=*/7)));
   ASSERT_TRUE(result_70.Equals(expected_70));
 
   auto expected_20 = ArrayFromJSON(int64(), day_of_week_week_start_2_zero_based);
   ASSERT_OK_AND_ASSIGN(
       Datum result_20,
-      DayOfWeek(timestamps, TemporalComponentExtractionOptions(
+      DayOfWeek(timestamps, DayOfWeekOptions(
                                 /*one_based_numbering=*/false, /*week_start=*/2)));
   ASSERT_TRUE(result_20.Equals(expected_20));
 
   auto expected_71 = ArrayFromJSON(int64(), day_of_week_week_start_7_one_based);
   ASSERT_OK_AND_ASSIGN(
       Datum result_71,
-      DayOfWeek(timestamps, TemporalComponentExtractionOptions(
+      DayOfWeek(timestamps, DayOfWeekOptions(
                                 /*one_based_numbering=*/true, /*week_start=*/7)));
   ASSERT_TRUE(result_71.Equals(expected_71));
 
   auto expected_21 = ArrayFromJSON(int64(), day_of_week_week_start_2_one_based);
   ASSERT_OK_AND_ASSIGN(
       Datum result_21,
-      DayOfWeek(timestamps, TemporalComponentExtractionOptions(
+      DayOfWeek(timestamps, DayOfWeekOptions(
                                 /*one_based_numbering=*/true, /*week_start=*/2)));
   ASSERT_TRUE(result_21.Equals(expected_21));
 }
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index edb8b8592ac..de46cc0b78f 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -988,46 +988,46 @@ Temporal component extraction
 These functions extract datetime components (year, month, day, etc) from timestamp type.
 Note: this is currently not supported for timestamps with timezone information.
 
-+--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
-| Function name      | Arity      | Input types       | Output type   | Notes  | Options class                                |
-+====================+============+===================+===============+========+==============================================+
-| year               | Unary      | Temporal          | Int64         |        |                                              |
-+--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
-| month              | Unary      | Temporal          | Int64         |        |                                              |
-+--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
-| day                | Unary      | Temporal          | Int64         |        |                                              |
-+--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
-| day_of_week        | Unary      | Temporal          | Int64         | \(1)   | :struct:`TemporalComponentExtractionOptions` |
-+--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
-| day_of_year        | Unary      | Temporal          | Int64         |        |                                              |
-+--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
-| iso_year           | Unary      | Temporal          | Int64         | \(2)   |                                              |
-+--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
-| iso_week           | Unary      | Temporal          | Int64         | \(2)   |                                              |
-+--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
-| iso_calendar       | Unary      | Temporal          | Struct        | \(3)   |                                              |
-+--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
-| quarter            | Unary      | Temporal          | Int64         |        |                                              |
-+--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
-| hour               | Unary      | Temporal          | Int64         |        |                                              |
-+--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
-| minute             | Unary      | Temporal          | Int64         |        |                                              |
-+--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
-| second             | Unary      | Temporal          | Int64         |        |                                              |
-+--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
-| millisecond        | Unary      | Temporal          | Int64         |        |                                              |
-+--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
-| microsecond        | Unary      | Temporal          | Int64         |        |                                              |
-+--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
-| nanosecond         | Unary      | Temporal          | Int64         |        |                                              |
-+--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
-| subsecond          | Unary      | Temporal          | Double        |        |                                              |
-+--------------------+------------+-------------------+---------------+--------+----------------------------------------------+
++--------------------+------------+-------------------+---------------+--------+----------------------------+
+| Function name      | Arity      | Input types       | Output type   | Notes  | Options class              |
++====================+============+===================+===============+========+============================+
+| year               | Unary      | Temporal          | Int64         |        |                            |
++--------------------+------------+-------------------+---------------+--------+----------------------------+
+| month              | Unary      | Temporal          | Int64         |        |                            |
++--------------------+------------+-------------------+---------------+--------+----------------------------+
+| day                | Unary      | Temporal          | Int64         |        |                            |
++--------------------+------------+-------------------+---------------+--------+----------------------------+
+| day_of_week        | Unary      | Temporal          | Int64         | \(1)   | :struct:`DayOfWeekOptions` |
++--------------------+------------+-------------------+---------------+--------+----------------------------+
+| day_of_year        | Unary      | Temporal          | Int64         |        |                            |
++--------------------+------------+-------------------+---------------+--------+----------------------------+
+| iso_year           | Unary      | Temporal          | Int64         | \(2)   |                            |
++--------------------+------------+-------------------+---------------+--------+----------------------------+
+| iso_week           | Unary      | Temporal          | Int64         | \(2)   |                            |
++--------------------+------------+-------------------+---------------+--------+----------------------------+
+| iso_calendar       | Unary      | Temporal          | Struct        | \(3)   |                            |
++--------------------+------------+-------------------+---------------+--------+----------------------------+
+| quarter            | Unary      | Temporal          | Int64         |        |                            |
++--------------------+------------+-------------------+---------------+--------+----------------------------+
+| hour               | Unary      | Temporal          | Int64         |        |                            |
++--------------------+------------+-------------------+---------------+--------+----------------------------+
+| minute             | Unary      | Temporal          | Int64         |        |                            |
++--------------------+------------+-------------------+---------------+--------+----------------------------+
+| second             | Unary      | Temporal          | Int64         |        |                            |
++--------------------+------------+-------------------+---------------+--------+----------------------------+
+| millisecond        | Unary      | Temporal          | Int64         |        |                            |
++--------------------+------------+-------------------+---------------+--------+----------------------------+
+| microsecond        | Unary      | Temporal          | Int64         |        |                            |
++--------------------+------------+-------------------+---------------+--------+----------------------------+
+| nanosecond         | Unary      | Temporal          | Int64         |        |                            |
++--------------------+------------+-------------------+---------------+--------+----------------------------+
+| subsecond          | Unary      | Temporal          | Double        |        |                            |
++--------------------+------------+-------------------+---------------+--------+----------------------------+
 
 * \(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:`TemporalComponentExtractionOptions::week_start`
-  can be used to set the starting day of the week using ISO convention (Monday=1, Sunday=7). Day numbering can
-  start with 0 or 1 using :member:`TemporalComponentExtractionOptions::week_start` paramter.
+  represented by 0 and ends on Sunday represented by 6. :member:`DayOfWeekOptions::week_start` can be used to set
+  the starting day of the week using ISO convention (Monday=1, Sunday=7). Day numbering can start with 0 or 1
+  using :member:`DayOfWeekOptions::week_start` paramter.
 * \(2) First ISO week has the majority (4 or more) of it's days in January. ISO year
   starts with the first ISO week.
   See `ISO 8601 week date definition`_ for more details.

From 4fdcb7ff9e46a1dfc2af179ce699670b70dd43d7 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Wed, 30 Jun 2021 17:39:48 +0200
Subject: [PATCH 08/15] Refatoring scalar_temporal_test.cc.

---
 .../compute/kernels/scalar_temporal_test.cc   | 164 ++++++++----------
 1 file changed, 77 insertions(+), 87 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
index c3315e0a7d1..7be5b25167a 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
@@ -26,11 +26,8 @@ namespace arrow {
 
 using internal::StringFormatter;
 
-class ScalarTemporalTest : public ::testing::Test {};
-
-namespace compute {
-
-TEST(ScalarTemporalTest, TestTemporalComponentExtraction) {
+class ScalarTemporalTest : public ::testing::Test {
+ public:
   const char* times =
       R"(["1970-01-01T00:00:59.123456789","2000-02-29T23:23:23.999999999",
           "1899-01-01T00:59:20.001001001","2033-05-18T03:33:20.000000000",
@@ -39,52 +36,70 @@ TEST(ScalarTemporalTest, TestTemporalComponentExtraction) {
           "2010-01-01T05:25:25.005321", "2010-01-03T06:30:30.006163",
           "2010-01-04T07:35:35", "2006-01-01T08:40:40", "2005-12-31T09:45:45",
           "2008-12-28", "2008-12-29", "2012-01-01 01:02:03"])";
-  auto unit = timestamp(TimeUnit::NANO);
-  auto iso_calendar_type =
+  const char* times_seconds_precision =
+      R"(["1970-01-01T00:00:59","2000-02-29T23:23:23",
+          "1899-01-01T00:59:20","2033-05-18T03:33:20",
+          null, "2020-01-01T01:05:05", "2019-12-31T02:10:10",
+          "2019-12-30T03:15:15", "2009-12-31T04:20:20",
+          "2010-01-01T05:25:25", "2010-01-03T06:30:30",
+          "2010-01-04T07:35:35", "2006-01-01T08:40:40", "2005-12-31T09:45:45",
+          "2008-12-28", "2008-12-29", "2012-01-01 01:02:03"])";
+  std::shared_ptr<arrow::DataType> iso_calendar_type =
       struct_({field("iso_year", int64()), field("iso_week", int64()),
                field("iso_day_of_week", int64())});
-
-  auto year =
+  std::shared_ptr<arrow::Array> iso_calendar =
+      ArrayFromJSON(iso_calendar_type,
+                    R"([{"iso_year": 1970, "iso_week": 1, "iso_day_of_week": 4},
+                          {"iso_year": 2000, "iso_week": 9, "iso_day_of_week": 2},
+                          {"iso_year": 1898, "iso_week": 52, "iso_day_of_week": 7},
+                          {"iso_year": 2033, "iso_week": 20, "iso_day_of_week": 3},
+                          null,
+                          {"iso_year": 2020, "iso_week": 1, "iso_day_of_week": 3},
+                          {"iso_year": 2020, "iso_week": 1, "iso_day_of_week": 2},
+                          {"iso_year": 2020, "iso_week": 1, "iso_day_of_week": 1},
+                          {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 4},
+                          {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 5},
+                          {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 7},
+                          {"iso_year": 2010, "iso_week": 1, "iso_day_of_week": 1},
+                          {"iso_year": 2005, "iso_week": 52, "iso_day_of_week": 7},
+                          {"iso_year": 2005, "iso_week": 52, "iso_day_of_week": 6},
+                          {"iso_year": 2008, "iso_week": 52, "iso_day_of_week": 7},
+                          {"iso_year": 2009, "iso_week": 1, "iso_day_of_week": 1},
+                          {"iso_year": 2011, "iso_week": 52, "iso_day_of_week": 7}])");
+  std::string year =
       "[1970, 2000, 1899, 2033, null, 2020, 2019, 2019, 2009, 2010, 2010, 2010, 2006, "
       "2005, 2008, 2008, 2012]";
-  auto month = "[1, 2, 1, 5, null, 1, 12, 12, 12, 1, 1, 1, 1, 12, 12, 12, 1]";
-  auto day = "[1, 29, 1, 18, null, 1, 31, 30, 31, 1, 3, 4, 1, 31, 28, 29, 1]";
-  auto day_of_week = "[3, 1, 6, 2, null, 2, 1, 0, 3, 4, 6, 0, 6, 5, 6, 0, 6]";
-  auto day_of_year =
+  std::string month = "[1, 2, 1, 5, null, 1, 12, 12, 12, 1, 1, 1, 1, 12, 12, 12, 1]";
+  std::string day = "[1, 29, 1, 18, null, 1, 31, 30, 31, 1, 3, 4, 1, 31, 28, 29, 1]";
+  std::string day_of_week = "[3, 1, 6, 2, null, 2, 1, 0, 3, 4, 6, 0, 6, 5, 6, 0, 6]";
+  std::string day_of_year =
       "[1, 60, 1, 138, null, 1, 365, 364, 365, 1, 3, 4, 1, 365, 363, 364, 1]";
-  auto iso_year =
+  std::string iso_year =
       "[1970, 2000, 1898, 2033, null, 2020, 2020, 2020, 2009, 2009, 2009, 2010, 2005, "
       "2005, 2008, 2009, 2011]";
-  auto iso_week = "[1, 9, 52, 20, null, 1, 1, 1, 53, 53, 53, 1, 52, 52, 52, 1, 52]";
-  auto iso_calendar =
-      ArrayFromJSON(iso_calendar_type,
-                    R"([{"iso_year": 1970, "iso_week": 1, "iso_day_of_week": 4},
-                        {"iso_year": 2000, "iso_week": 9, "iso_day_of_week": 2},
-                        {"iso_year": 1898, "iso_week": 52, "iso_day_of_week": 7},
-                        {"iso_year": 2033, "iso_week": 20, "iso_day_of_week": 3},
-                        null,
-                        {"iso_year": 2020, "iso_week": 1, "iso_day_of_week": 3},
-                        {"iso_year": 2020, "iso_week": 1, "iso_day_of_week": 2},
-                        {"iso_year": 2020, "iso_week": 1, "iso_day_of_week": 1},
-                        {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 4},
-                        {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 5},
-                        {"iso_year": 2009, "iso_week": 53, "iso_day_of_week": 7},
-                        {"iso_year": 2010, "iso_week": 1, "iso_day_of_week": 1},
-                        {"iso_year": 2005, "iso_week": 52, "iso_day_of_week": 7},
-                        {"iso_year": 2005, "iso_week": 52, "iso_day_of_week": 6},
-                        {"iso_year": 2008, "iso_week": 52, "iso_day_of_week": 7},
-                        {"iso_year": 2009, "iso_week": 1, "iso_day_of_week": 1},
-                        {"iso_year": 2011, "iso_week": 52, "iso_day_of_week": 7}])");
-  auto quarter = "[1, 1, 1, 2, null, 1, 4, 4, 4, 1, 1, 1, 1, 4, 4, 4, 1]";
-  auto hour = "[0, 23, 0, 3, null, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1]";
-  auto minute = "[0, 23, 59, 33, null, 5, 10, 15, 20, 25, 30, 35, 40, 45, 0, 0, 2]";
-  auto second = "[59, 23, 20, 20, null, 5, 10, 15, 20, 25, 30, 35, 40, 45, 0, 0, 3]";
-  auto millisecond = "[123, 999, 1, 0, null, 1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0, 0]";
-  auto microsecond = "[456, 999, 1, 0, null, 0, 0, 0, 132, 321, 163, 0, 0, 0, 0, 0, 0]";
-  auto nanosecond = "[789, 999, 1, 0, null, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]";
-  auto subsecond =
+  std::string iso_week =
+      "[1, 9, 52, 20, null, 1, 1, 1, 53, 53, 53, 1, 52, 52, 52, 1, 52]";
+
+  std::string quarter = "[1, 1, 1, 2, null, 1, 4, 4, 4, 1, 1, 1, 1, 4, 4, 4, 1]";
+  std::string hour = "[0, 23, 0, 3, null, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1]";
+  std::string minute =
+      "[0, 23, 59, 33, null, 5, 10, 15, 20, 25, 30, 35, 40, 45, 0, 0, 2]";
+  std::string second =
+      "[59, 23, 20, 20, null, 5, 10, 15, 20, 25, 30, 35, 40, 45, 0, 0, 3]";
+  std::string millisecond = "[123, 999, 1, 0, null, 1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0, 0]";
+  std::string microsecond =
+      "[456, 999, 1, 0, null, 0, 0, 0, 132, 321, 163, 0, 0, 0, 0, 0, 0]";
+  std::string nanosecond = "[789, 999, 1, 0, null, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]";
+  std::string subsecond =
       "[0.123456789, 0.999999999, 0.001001001, 0, null, 0.001, 0.002, 0.003, 0.004132, "
       "0.005321, 0.006163, 0, 0, 0, 0, 0, 0]";
+  std::string zeros = "[0, 0, 0, 0, null, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]";
+};
+
+namespace compute {
+
+TEST_F(ScalarTemporalTest, TestTemporalComponentExtraction) {
+  auto unit = timestamp(TimeUnit::NANO);
 
   CheckScalarUnary("year", unit, times, int64(), year);
   CheckScalarUnary("month", unit, times, int64(), month);
@@ -142,60 +157,35 @@ TEST(ScalarTemporalTest, TestTemporalComponentExtraction) {
   ASSERT_TRUE(result_21.Equals(expected_21));
 }
 
-TEST(ScalarTemporalTest, TestTemporalComponentExtractionWithDifferentUnits) {
-  auto iso_calendar_type =
-      struct_({field("iso_year", int64()), field("iso_week", int64()),
-               field("iso_day_of_week", int64())});
-  const char* times =
-      R"(["1970-01-01T00:00:59","2000-02-29T23:23:23",
-            "1899-01-01T00:59:20","2033-05-18T03:33:20", null])";
-  auto year = "[1970, 2000, 1899, 2033, null]";
-  auto month = "[1, 2, 1, 5, null]";
-  auto day = "[1, 29, 1, 18, null]";
-  auto day_of_week = "[3, 1, 6, 2, null]";
-  auto day_of_year = "[1, 60, 1, 138, null]";
-  auto iso_year = "[1970, 2000, 1898, 2033, null]";
-  auto iso_week = "[1, 9, 52, 20, null]";
-  auto iso_calendar =
-      ArrayFromJSON(iso_calendar_type,
-                    R"([{"iso_year": 1970, "iso_week": 1, "iso_day_of_week": 4},
-                          {"iso_year": 2000, "iso_week": 9, "iso_day_of_week": 2},
-                          {"iso_year": 1898, "iso_week": 52, "iso_day_of_week": 7},
-                          {"iso_year": 2033, "iso_week": 20, "iso_day_of_week": 3}, null])");
-  auto quarter = "[1, 1, 1, 2, null]";
-  auto hour = "[0, 23, 0, 3, null]";
-  auto minute = "[0, 23, 59, 33, null]";
-  auto second = "[59, 23, 20, 20, null]";
-  auto zeros = "[0, 0, 0, 0, null]";
-
+TEST_F(ScalarTemporalTest, TestTemporalComponentExtractionWithDifferentUnits) {
   for (auto u : internal::AllTimeUnits()) {
     auto unit = timestamp(u);
-    CheckScalarUnary("year", unit, times, int64(), year);
-    CheckScalarUnary("month", unit, times, int64(), month);
-    CheckScalarUnary("day", unit, times, int64(), day);
-    CheckScalarUnary("day_of_week", unit, times, int64(), day_of_week);
-    CheckScalarUnary("day_of_year", unit, times, int64(), day_of_year);
-    CheckScalarUnary("iso_year", unit, times, int64(), iso_year);
-    CheckScalarUnary("iso_week", unit, times, int64(), iso_week);
-    CheckScalarUnary("iso_calendar", ArrayFromJSON(unit, times), iso_calendar);
-    CheckScalarUnary("quarter", unit, times, int64(), quarter);
-    CheckScalarUnary("hour", unit, times, int64(), hour);
-    CheckScalarUnary("minute", unit, times, int64(), minute);
-    CheckScalarUnary("second", unit, times, float64(), second);
-    CheckScalarUnary("millisecond", unit, times, int64(), zeros);
-    CheckScalarUnary("microsecond", unit, times, int64(), zeros);
-    CheckScalarUnary("nanosecond", unit, times, int64(), zeros);
-    CheckScalarUnary("subsecond", unit, times, float64(), zeros);
+    CheckScalarUnary("year", unit, times_seconds_precision, int64(), year);
+    CheckScalarUnary("month", unit, times_seconds_precision, int64(), month);
+    CheckScalarUnary("day", unit, times_seconds_precision, int64(), day);
+    CheckScalarUnary("day_of_week", unit, times_seconds_precision, int64(), day_of_week);
+    CheckScalarUnary("day_of_year", unit, times_seconds_precision, int64(), day_of_year);
+    CheckScalarUnary("iso_year", unit, times_seconds_precision, int64(), iso_year);
+    CheckScalarUnary("iso_week", unit, times_seconds_precision, int64(), iso_week);
+    CheckScalarUnary("iso_calendar", ArrayFromJSON(unit, times_seconds_precision),
+                     iso_calendar);
+    CheckScalarUnary("quarter", unit, times_seconds_precision, int64(), quarter);
+    CheckScalarUnary("hour", unit, times_seconds_precision, int64(), hour);
+    CheckScalarUnary("minute", unit, times_seconds_precision, int64(), minute);
+    CheckScalarUnary("second", unit, times_seconds_precision, float64(), second);
+    CheckScalarUnary("millisecond", unit, times_seconds_precision, int64(), zeros);
+    CheckScalarUnary("microsecond", unit, times_seconds_precision, int64(), zeros);
+    CheckScalarUnary("nanosecond", unit, times_seconds_precision, int64(), zeros);
+    CheckScalarUnary("subsecond", unit, times_seconds_precision, float64(), zeros);
   }
 }
 
-TEST(ScalarTemporalTest, TestZonedTemporalComponentExtraction) {
+TEST_F(ScalarTemporalTest, TestZonedTemporalComponentExtraction) {
   std::string timezone = "Asia/Kolkata";
-  const char* times = R"(["1970-01-01T00:00:59", null])";
 
   for (auto u : internal::AllTimeUnits()) {
     auto unit = timestamp(u, timezone);
-    auto timestamps = ArrayFromJSON(unit, times);
+    auto timestamps = ArrayFromJSON(unit, times_seconds_precision);
 
     ASSERT_RAISES(NotImplemented, Year(timestamps));
     ASSERT_RAISES(NotImplemented, Month(timestamps));

From 6c94f2034fb2e6b79a8ee00bd59c6eacdc6ba670 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Wed, 30 Jun 2021 20:19:48 +0200
Subject: [PATCH 09/15] Adding Python wrapper for DayOfWeekOptions.

---
 cpp/src/arrow/compute/api_scalar.cc           |  2 +-
 cpp/src/arrow/compute/api_scalar.h            |  5 +-
 .../arrow/compute/kernels/scalar_temporal.cc  |  2 +-
 .../compute/kernels/scalar_temporal_test.cc   |  4 +-
 python/pyarrow/_compute.pyx                   | 17 +++++
 python/pyarrow/compute.py                     |  1 +
 python/pyarrow/includes/libarrow.pxd          |  6 ++
 python/pyarrow/tests/test_compute.py          | 74 +++++++++++++++++++
 r/src/compute.cpp                             |  3 +
 9 files changed, 107 insertions(+), 7 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index 5628b223850..9e9fc247ece 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -471,7 +471,7 @@ SCALAR_EAGER_UNARY(Microsecond, "microsecond")
 SCALAR_EAGER_UNARY(Nanosecond, "nanosecond")
 SCALAR_EAGER_UNARY(Subsecond, "subsecond")
 
-Result<Datum> DayOfWeek(const Datum& arg, DayOfWeekOptions options, ExecContext* ctx) {
+Result<Datum> DayOfWeek(const Datum& arg, const DayOfWeekOptions options, ExecContext* ctx) {
   return CallFunction("day_of_week", {arg}, &options, ctx);
 }
 
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index e79f2bd74bf..6bedb5baef3 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -246,8 +246,7 @@ class ARROW_EXPORT ProjectOptions : public FunctionOptions {
 
 struct ARROW_EXPORT DayOfWeekOptions : public FunctionOptions {
   explicit DayOfWeekOptions(bool one_based_numbering = false, uint32_t week_start = 1)
-      : one_based_numbering(std::move(one_based_numbering)),
-        week_start(std::move(week_start)) {}
+      : one_based_numbering(one_based_numbering), week_start(week_start) {}
 
   static DayOfWeekOptions Defaults() { return DayOfWeekOptions{}; }
 
@@ -738,7 +737,7 @@ Result<Datum> Day(const Datum& values, ExecContext* ctx = NULLPTR);
 /// \since 5.0.0
 /// \note API not yet finalized
 ARROW_EXPORT Result<Datum> DayOfWeek(
-    const Datum& values, DayOfWeekOptions options = DayOfWeekOptions::Defaults(),
+    const Datum& values, const DayOfWeekOptions options = DayOfWeekOptions::Defaults(),
     ExecContext* ctx = NULLPTR);
 
 /// \brief DayOfYear returns number of day of the year for each element of `values`.
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index 08b067a31da..72428cd1e80 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -635,7 +635,7 @@ void RegisterScalarTemporal(FunctionRegistry* registry) {
   auto minute = MakeTemporal<Minute, Int64Type>("minute", &minute_doc);
   DCHECK_OK(registry->AddFunction(std::move(minute)));
 
-  auto second = MakeTemporal<Second, DoubleType>("second", &second_doc);
+  auto second = MakeTemporal<Second, Int64Type>("second", &second_doc);
   DCHECK_OK(registry->AddFunction(std::move(second)));
 
   auto millisecond =
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
index 7be5b25167a..aac846c35c1 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
@@ -112,7 +112,7 @@ TEST_F(ScalarTemporalTest, TestTemporalComponentExtraction) {
   CheckScalarUnary("quarter", unit, times, int64(), quarter);
   CheckScalarUnary("hour", unit, times, int64(), hour);
   CheckScalarUnary("minute", unit, times, int64(), minute);
-  CheckScalarUnary("second", unit, times, float64(), second);
+  CheckScalarUnary("second", unit, times, int64(), second);
   CheckScalarUnary("millisecond", unit, times, int64(), millisecond);
   CheckScalarUnary("microsecond", unit, times, int64(), microsecond);
   CheckScalarUnary("nanosecond", unit, times, int64(), nanosecond);
@@ -172,7 +172,7 @@ TEST_F(ScalarTemporalTest, TestTemporalComponentExtractionWithDifferentUnits) {
     CheckScalarUnary("quarter", unit, times_seconds_precision, int64(), quarter);
     CheckScalarUnary("hour", unit, times_seconds_precision, int64(), hour);
     CheckScalarUnary("minute", unit, times_seconds_precision, int64(), minute);
-    CheckScalarUnary("second", unit, times_seconds_precision, float64(), second);
+    CheckScalarUnary("second", unit, times_seconds_precision, int64(), second);
     CheckScalarUnary("millisecond", unit, times_seconds_precision, int64(), zeros);
     CheckScalarUnary("microsecond", unit, times_seconds_precision, int64(), zeros);
     CheckScalarUnary("nanosecond", unit, times_seconds_precision, int64(), zeros);
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 02855ee78aa..921e290bdbf 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -961,6 +961,23 @@ class StrptimeOptions(_StrptimeOptions):
         self._set_options(format, unit)
 
 
+cdef class _DayOfWeekOptions(FunctionOptions):
+    cdef:
+        unique_ptr[CDayOfWeekOptions] day_of_week_options
+
+    cdef const CFunctionOptions* get_options(self) except NULL:
+        return self.day_of_week_options.get()
+
+    def _set_options(self, one_based_numbering, week_start):
+        self.day_of_week_options.reset(
+            new CDayOfWeekOptions(one_based_numbering, week_start))
+
+
+class DayOfWeekOptions(_DayOfWeekOptions):
+    def __init__(self, one_based_numbering=True, week_start=1):
+        self._set_options(one_based_numbering, week_start)
+
+
 cdef class _VarianceOptions(FunctionOptions):
     def _set_options(self, ddof):
         self.wrapped.reset(new CVarianceOptions(ddof))
diff --git a/python/pyarrow/compute.py b/python/pyarrow/compute.py
index fbe9e2c5c0f..15d1adcbafe 100644
--- a/python/pyarrow/compute.py
+++ b/python/pyarrow/compute.py
@@ -52,6 +52,7 @@
     SplitOptions,
     SplitPatternOptions,
     StrptimeOptions,
+    DayOfWeekOptions,
     TakeOptions,
     TDigestOptions,
     TrimOptions,
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index 67a960fbacc..6977c26cac5 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -1940,6 +1940,12 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
             "arrow::compute::StrptimeOptions"(CFunctionOptions):
         CStrptimeOptions(c_string format, TimeUnit unit)
 
+    cdef cppclass CDayOfWeekOptions \
+            "arrow::compute::DayOfWeekOptions"(CFunctionOptions):
+        CDayOfWeekOptions(c_bool one_based_numbering, uint32_t week_start)
+        c_bool one_based_numbering
+        uint32_t week_start
+
     cdef cppclass CVarianceOptions \
             "arrow::compute::VarianceOptions"(CFunctionOptions):
         CVarianceOptions(int ddof)
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 35b37d82f95..3d621aafbbf 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -1346,6 +1346,80 @@ def test_strptime():
     assert got == expected
 
 
+def _check_datetime_components(timestamps, timezone=None):
+    from pyarrow.vendored.version import Version
+
+    ts = pd.to_datetime(timestamps).to_series()
+    tsa = pa.array(ts)
+
+    subseconds = ((ts.dt.microsecond * 10**3 +
+                   ts.dt.nanosecond) * 10**-9).round(9)
+    iso_calendar_fields = [
+        pa.field('iso_year', pa.int64()),
+        pa.field('iso_week', pa.int64()),
+        pa.field('iso_day_of_week', pa.int64())
+    ]
+
+    if Version(pd.__version__) < Version("1.1.0"):
+        # https://github.com/pandas-dev/pandas/issues/33206
+        iso_year = ts.map(lambda x: x.isocalendar()[0]).astype("Int64")
+        iso_week = ts.map(lambda x: x.isocalendar()[1]).astype("Int64")
+        iso_day = ts.map(lambda x: x.isocalendar()[2]).astype("Int64")
+    else:
+        # Casting is required because pandas isocalendar returns int32
+        # while arrow isocalendar returns int64.
+        iso_year = ts.dt.isocalendar()["year"].astype("Int64")
+        iso_week = ts.dt.isocalendar()["week"].astype("Int64")
+        iso_day = ts.dt.isocalendar()["day"].astype("Int64")
+
+    iso_calendar = pa.StructArray.from_arrays(
+        [iso_year, iso_week, iso_day],
+        fields=iso_calendar_fields)
+
+    assert pc.year(tsa).equals(pa.array(ts.dt.year))
+    assert pc.month(tsa).equals(pa.array(ts.dt.month))
+    assert pc.day(tsa).equals(pa.array(ts.dt.day))
+    assert pc.day_of_week(tsa).equals(pa.array(ts.dt.dayofweek))
+    assert pc.day_of_year(tsa).equals(pa.array(ts.dt.dayofyear))
+    assert pc.iso_year(tsa).equals(pa.array(iso_year))
+    assert pc.iso_week(tsa).equals(pa.array(iso_week))
+    assert pc.iso_calendar(tsa).equals(iso_calendar)
+    assert pc.quarter(tsa).equals(pa.array(ts.dt.quarter))
+    assert pc.hour(tsa).equals(pa.array(ts.dt.hour))
+    assert pc.minute(tsa).equals(pa.array(ts.dt.minute))
+    assert pc.second(tsa).equals(pa.array(ts.dt.second.values))
+    assert pc.millisecond(tsa).equals(pa.array(ts.dt.microsecond // 10**3))
+    assert pc.microsecond(tsa).equals(pa.array(ts.dt.microsecond % 10**3))
+    assert pc.nanosecond(tsa).equals(pa.array(ts.dt.nanosecond))
+    assert pc.subsecond(tsa).equals(pa.array(subseconds))
+
+    day_of_week_options = pc.DayOfWeekOptions(
+        one_based_numbering=True, week_start=1)
+    assert pc.day_of_week(tsa, options=day_of_week_options).equals(
+        pa.array(ts.dt.dayofweek+1))
+
+
+@pytest.mark.pandas
+def test_extract_datetime_components():
+    timestamps = ["1970-01-01T00:00:59.123456789",
+                  "2000-02-29T23:23:23.999999999",
+                  "2033-05-18T03:33:20.000000000",
+                  "2020-01-01T01:05:05.001",
+                  "2019-12-31T02:10:10.002",
+                  "2019-12-30T03:15:15.003",
+                  "2009-12-31T04:20:20.004132",
+                  "2010-01-01T05:25:25.005321",
+                  "2010-01-03T06:30:30.006163",
+                  "2010-01-04T07:35:35",
+                  "2006-01-01T08:40:40",
+                  "2005-12-31T09:45:45",
+                  "2008-12-28",
+                  "2008-12-29",
+                  "2012-01-01 01:02:03"]
+
+    _check_datetime_components(timestamps)
+
+
 def test_count():
     arr = pa.array([1, 2, 3, None, None])
     assert pc.count(arr).as_py() == 3
diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index 39f7359d29f..7a899166a57 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -267,6 +267,9 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
   if (func_name == "day_of_week") {
     using Options = arrow::compute::TemporalComponentExtractionOptions;
     bool one_based_numbering = true;
+    if (!Rf_isNull(options["one_based_numbering"])) {
+      one_based_numbering = cpp11::as_cpp<bool>(options["one_based_numbering"]);
+    }
     return std::make_shared<Options>(one_based_numbering,
                                      cpp11::as_cpp<uint32_t>(options["week_start"]));
   }

From b8277a3697b5c6204d5a255f55a7a1565a5b3f9d Mon Sep 17 00:00:00 2001
From: Rok Mihevc <rok@mihevc.org>
Date: Wed, 30 Jun 2021 22:44:21 +0200
Subject: [PATCH 10/15] Update r/src/compute.cpp

Co-authored-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 cpp/src/arrow/compute/api_scalar.cc | 2 +-
 cpp/src/arrow/compute/api_scalar.h  | 5 +++--
 r/src/compute.cpp                   | 2 +-
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index 9e9fc247ece..5628b223850 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -471,7 +471,7 @@ SCALAR_EAGER_UNARY(Microsecond, "microsecond")
 SCALAR_EAGER_UNARY(Nanosecond, "nanosecond")
 SCALAR_EAGER_UNARY(Subsecond, "subsecond")
 
-Result<Datum> DayOfWeek(const Datum& arg, const DayOfWeekOptions options, ExecContext* ctx) {
+Result<Datum> DayOfWeek(const Datum& arg, DayOfWeekOptions options, ExecContext* ctx) {
   return CallFunction("day_of_week", {arg}, &options, ctx);
 }
 
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 6bedb5baef3..e24ac405533 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -245,8 +245,9 @@ class ARROW_EXPORT ProjectOptions : public FunctionOptions {
 };
 
 struct ARROW_EXPORT DayOfWeekOptions : public FunctionOptions {
-  explicit DayOfWeekOptions(bool one_based_numbering = false, uint32_t week_start = 1)
+  explicit DayOfWeekOptions(bool one_based_numbering, uint32_t week_start)
       : one_based_numbering(one_based_numbering), week_start(week_start) {}
+  explicit DayOfWeekOptions() : one_based_numbering(false), week_start(1) {}
 
   static DayOfWeekOptions Defaults() { return DayOfWeekOptions{}; }
 
@@ -737,7 +738,7 @@ Result<Datum> Day(const Datum& values, ExecContext* ctx = NULLPTR);
 /// \since 5.0.0
 /// \note API not yet finalized
 ARROW_EXPORT Result<Datum> DayOfWeek(
-    const Datum& values, const DayOfWeekOptions options = DayOfWeekOptions::Defaults(),
+    const Datum& values, DayOfWeekOptions options = DayOfWeekOptions::Defaults(),
     ExecContext* ctx = NULLPTR);
 
 /// \brief DayOfYear returns number of day of the year for each element of `values`.
diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index 7a899166a57..9be1cc3a83e 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -265,7 +265,7 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
   }
 
   if (func_name == "day_of_week") {
-    using Options = arrow::compute::TemporalComponentExtractionOptions;
+    using Options = arrow::compute::DayOfWeekOptions;
     bool one_based_numbering = true;
     if (!Rf_isNull(options["one_based_numbering"])) {
       one_based_numbering = cpp11::as_cpp<bool>(options["one_based_numbering"]);

From cebb6069f07069bc700d156888078372dbb05a2c Mon Sep 17 00:00:00 2001
From: Rok Mihevc <rok@mihevc.org>
Date: Thu, 1 Jul 2021 10:51:39 +0200
Subject: [PATCH 11/15] Apply suggestions from code review

Co-authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 cpp/src/arrow/compute/api_scalar.h                |  5 ++---
 cpp/src/arrow/compute/kernels/scalar_temporal.cc  | 15 ++++++++++++---
 .../arrow/compute/kernels/scalar_temporal_test.cc |  7 +++++++
 docs/source/cpp/compute.rst                       |  2 +-
 python/pyarrow/_compute.pyx                       |  2 +-
 5 files changed, 23 insertions(+), 8 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index e24ac405533..2b2e0a859ae 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -245,13 +245,12 @@ class ARROW_EXPORT ProjectOptions : public FunctionOptions {
 };
 
 struct ARROW_EXPORT DayOfWeekOptions : public FunctionOptions {
-  explicit DayOfWeekOptions(bool one_based_numbering, uint32_t week_start)
+  explicit DayOfWeekOptions(bool one_based_numbering = false, uint32_t week_start = 1)
       : one_based_numbering(one_based_numbering), week_start(week_start) {}
-  explicit DayOfWeekOptions() : one_based_numbering(false), week_start(1) {}
 
   static DayOfWeekOptions Defaults() { return DayOfWeekOptions{}; }
 
-  /// Number days from 1 if true and form 0 if false
+  /// Number days from 1 if true and from 0 if false
   bool one_based_numbering;
   /// What day does the week start with (Monday=1, Sunday=7)
   uint32_t week_start;
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index 72428cd1e80..b8cb163c3c0 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -90,6 +90,11 @@ struct DayOfWeekOptionsWithOptions {
 
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
     DayOfWeekOptions options = DayOfWeekState::Get(ctx);
+    if (options.week_start < 1 || 7 < options.week_start) {
+      return Status::Invalid(
+          "week_start must follow ISO convention (Monday=1, Sunday=7). Got week_start=",
+          options.week_start);
+    }
 
     RETURN_NOT_OK(TemporalComponentExtractCheckTimezone(batch.values[0]));
     applicator::ScalarUnaryNotNullStateful<OutType, TimestampType, Op> kernel{
@@ -151,6 +156,9 @@ struct DayOfWeek {
                   floor<days>(sys_time<Duration>(Duration{arg})))
                   .weekday()
                   .iso_encoding();
+    if (options.week_start == 1) {
+      return wd + options.one_based_numbering - 1;
+    }
     return (wd + 7 - options.week_start) % 7 + options.one_based_numbering;
   }
 
@@ -517,12 +525,13 @@ const FunctionDoc day_doc{
 
 const FunctionDoc day_of_week_doc{
     "Extract day of the week number",
-    ("By default Week starts on Monday represented by 0 and ends on Sunday represented "
+    ("By default, the week starts on Monday represented by 0 and ends on Sunday "
+     "represented "
      "by 6.\n"
-     "Returns an error if timestamp has a defined timezone. Null values return null.\n"
      "DayOfWeekOptions.week_start can be used to set another starting day using ISO "
      "convention (Monday=1, Sunday=7). Day numbering can start with 0 or 1 using "
-     "DayOfWeekOptions.one_based_numbering parameter."),
+     "DayOfWeekOptions.one_based_numbering parameter.\n"
+     "Returns an error if timestamp has a defined timezone. Null values return null."),
     {"values"},
     "DayOfWeekOptions"};
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
index aac846c35c1..ac03d3727ac 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
@@ -155,6 +155,13 @@ TEST_F(ScalarTemporalTest, TestTemporalComponentExtraction) {
       DayOfWeek(timestamps, DayOfWeekOptions(
                                 /*one_based_numbering=*/true, /*week_start=*/2)));
   ASSERT_TRUE(result_21.Equals(expected_21));
+
+  ASSERT_RAISES(Invalid,
+                DayOfWeek(timestamps, DayOfWeekOptions(/*one_based_numbering=*/true,
+                                                       /*week_start=*/0)));
+  ASSERT_RAISES(Invalid,
+                DayOfWeek(timestamps, DayOfWeekOptions(/*one_based_numbering=*/false,
+                                                       /*week_start=*/8)));
 }
 
 TEST_F(ScalarTemporalTest, TestTemporalComponentExtractionWithDifferentUnits) {
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index de46cc0b78f..a59bd6373cf 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1027,7 +1027,7 @@ Note: this is currently not supported for timestamps with timezone information.
 * \(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
   the starting day of the week using ISO convention (Monday=1, Sunday=7). Day numbering can start with 0 or 1
-  using :member:`DayOfWeekOptions::week_start` paramter.
+  using :member:`DayOfWeekOptions::week_start` parameter.
 * \(2) First ISO week has the majority (4 or more) of it's days in January. ISO year
   starts with the first ISO week.
   See `ISO 8601 week date definition`_ for more details.
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 921e290bdbf..86c8218e67e 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -974,7 +974,7 @@ cdef class _DayOfWeekOptions(FunctionOptions):
 
 
 class DayOfWeekOptions(_DayOfWeekOptions):
-    def __init__(self, one_based_numbering=True, week_start=1):
+    def __init__(self, one_based_numbering=False, week_start=1):
         self._set_options(one_based_numbering, week_start)
 
 

From ad24711f06688ade624b97d6255c8b28ba6ef6a6 Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Thu, 1 Jul 2021 13:40:38 +0200
Subject: [PATCH 12/15] Apply suggestions from code review.

---
 cpp/src/arrow/compute/api_scalar.cc           | 10 ++
 cpp/src/arrow/compute/api_scalar.h            | 16 ++--
 cpp/src/arrow/compute/function_test.cc        |  1 +
 .../arrow/compute/kernels/scalar_temporal.cc  | 43 +++++----
 .../compute/kernels/scalar_temporal_test.cc   | 94 ++++++++++---------
 docs/source/cpp/compute.rst                   |  2 +-
 python/pyarrow/_compute.pyx                   | 11 +--
 python/pyarrow/tests/test_compute.py          |  1 +
 8 files changed, 95 insertions(+), 83 deletions(-)

diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index 5628b223850..1aae7988a67 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -158,6 +158,9 @@ static auto kProjectOptionsType = GetFunctionOptionsType<ProjectOptions>(
     DataMember("field_names", &ProjectOptions::field_names),
     DataMember("field_nullability", &ProjectOptions::field_nullability),
     DataMember("field_metadata", &ProjectOptions::field_metadata));
+static auto kDayOfWeekOptionsType = GetFunctionOptionsType<DayOfWeekOptions>(
+    DataMember("one_based_numbering", &DayOfWeekOptions::one_based_numbering),
+    DataMember("week_start", &DayOfWeekOptions::week_start));
 }  // namespace
 }  // namespace internal
 
@@ -278,6 +281,12 @@ ProjectOptions::ProjectOptions(std::vector<std::string> n)
 ProjectOptions::ProjectOptions() : ProjectOptions(std::vector<std::string>()) {}
 constexpr char ProjectOptions::kTypeName[];
 
+DayOfWeekOptions::DayOfWeekOptions(bool one_based_numbering, uint32_t week_start)
+    : FunctionOptions(internal::kDayOfWeekOptionsType),
+      one_based_numbering(one_based_numbering),
+      week_start(week_start) {}
+constexpr char DayOfWeekOptions::kTypeName[];
+
 namespace internal {
 void RegisterScalarOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kArithmeticOptionsType));
@@ -296,6 +305,7 @@ void RegisterScalarOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kSliceOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kCompareOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kProjectOptionsType));
+  DCHECK_OK(registry->AddFunctionOptionsType(kDayOfWeekOptionsType));
 }
 }  // namespace internal
 
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 2b2e0a859ae..07a8d706f89 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -245,9 +245,9 @@ class ARROW_EXPORT ProjectOptions : public FunctionOptions {
 };
 
 struct ARROW_EXPORT DayOfWeekOptions : public FunctionOptions {
-  explicit DayOfWeekOptions(bool one_based_numbering = false, uint32_t week_start = 1)
-      : one_based_numbering(one_based_numbering), week_start(week_start) {}
-
+ public:
+  explicit DayOfWeekOptions(bool one_based_numbering = false, uint32_t week_start = 1);
+  constexpr static char const kTypeName[] = "DayOfWeekOptions";
   static DayOfWeekOptions Defaults() { return DayOfWeekOptions{}; }
 
   /// Number days from 1 if true and from 0 if false
@@ -725,7 +725,9 @@ ARROW_EXPORT
 Result<Datum> Day(const Datum& values, ExecContext* ctx = NULLPTR);
 
 /// \brief DayOfWeek returns number of the day of the week value for each element of
-/// `values`. By default week starts on Monday denoted by 0 and ends on Sunday denoted
+/// `values`.
+///
+/// By default week starts on Monday denoted by 0 and ends on Sunday denoted
 /// by 6. Start day of the week (Monday=1, Sunday=7) and numbering base (0 or 1) can be
 /// set using DayOfWeekOptions
 ///
@@ -736,9 +738,9 @@ Result<Datum> Day(const Datum& values, ExecContext* ctx = NULLPTR);
 ///
 /// \since 5.0.0
 /// \note API not yet finalized
-ARROW_EXPORT Result<Datum> DayOfWeek(
-    const Datum& values, DayOfWeekOptions options = DayOfWeekOptions::Defaults(),
-    ExecContext* ctx = NULLPTR);
+ARROW_EXPORT Result<Datum> DayOfWeek(const Datum& values,
+                                     DayOfWeekOptions options = DayOfWeekOptions(),
+                                     ExecContext* ctx = NULLPTR);
 
 /// \brief DayOfYear returns number of day of the year for each element of `values`.
 /// January 1st maps to day number 1, February 1st to 32, etc.
diff --git a/cpp/src/arrow/compute/function_test.cc b/cpp/src/arrow/compute/function_test.cc
index bbe514af09a..752ade284b7 100644
--- a/cpp/src/arrow/compute/function_test.cc
+++ b/cpp/src/arrow/compute/function_test.cc
@@ -90,6 +90,7 @@ TEST(FunctionOptions, Equality) {
   options.emplace_back(new ProjectOptions({"col1"}, {false}, {}));
   options.emplace_back(
       new ProjectOptions({"col1"}, {false}, {key_value_metadata({{"key", "val"}})}));
+  options.emplace_back(new DayOfWeekOptions(false, 1));
   options.emplace_back(new CastOptions(CastOptions::Safe(boolean())));
   options.emplace_back(new CastOptions(CastOptions::Unsafe(int64())));
   options.emplace_back(new FilterOptions());
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index b8cb163c3c0..0a931c8db27 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -85,7 +85,7 @@ struct TemporalComponentExtract {
 };
 
 template <typename Op, typename OutType>
-struct DayOfWeekOptionsWithOptions {
+struct DayOfWeekExec {
   using OutValue = typename internal::GetOutputType<OutType>::T;
 
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
@@ -148,20 +148,23 @@ struct Day {
 
 template <typename Duration>
 struct DayOfWeek {
-  explicit DayOfWeek(DayOfWeekOptions options) : options(options) {}
+  explicit DayOfWeek(DayOfWeekOptions options) : options(options) {
+    for (int i = 0; i < 7; i++) {
+      lookup_table[i] = i + 8 - options.week_start;
+      lookup_table[i] = (lookup_table[i] > 6) ? lookup_table[i] - 7 : lookup_table[i];
+      lookup_table[i] += options.one_based_numbering;
+    }
+  }
 
   template <typename T, typename Arg0>
   T Call(KernelContext*, Arg0 arg, Status*) const {
-    auto wd = arrow_vendored::date::year_month_weekday(
-                  floor<days>(sys_time<Duration>(Duration{arg})))
-                  .weekday()
-                  .iso_encoding();
-    if (options.week_start == 1) {
-      return wd + options.one_based_numbering - 1;
-    }
-    return (wd + 7 - options.week_start) % 7 + options.one_based_numbering;
+    const auto wd = arrow_vendored::date::year_month_weekday(
+                        floor<days>(sys_time<Duration>(Duration{arg})))
+                        .weekday()
+                        .iso_encoding();
+    return lookup_table[wd - 1];
   }
-
+  std::array<int64_t, 7> lookup_table;
   DayOfWeekOptions options;
 };
 
@@ -435,35 +438,32 @@ std::shared_ptr<ScalarFunction> MakeTemporal(std::string name, const FunctionDoc
 
 template <template <typename...> class Op, typename OutType>
 std::shared_ptr<ScalarFunction> MakeTemporalWithOptions(
-    std::string name, const FunctionDoc* doc, const DayOfWeekOptions* default_options,
+    std::string name, const FunctionDoc* doc, const DayOfWeekOptions& default_options,
     KernelInit init) {
   const auto& out_type = TypeTraits<OutType>::type_singleton();
   auto func =
-      std::make_shared<ScalarFunction>(name, Arity::Unary(), doc, default_options);
+      std::make_shared<ScalarFunction>(name, Arity::Unary(), doc, &default_options);
 
   for (auto unit : internal::AllTimeUnits()) {
     InputType in_type{match::TimestampTypeUnit(unit)};
     switch (unit) {
       case TimeUnit::SECOND: {
-        auto exec = DayOfWeekOptionsWithOptions<Op<std::chrono::seconds>, OutType>::Exec;
+        auto exec = DayOfWeekExec<Op<std::chrono::seconds>, OutType>::Exec;
         DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
         break;
       }
       case TimeUnit::MILLI: {
-        auto exec =
-            DayOfWeekOptionsWithOptions<Op<std::chrono::milliseconds>, OutType>::Exec;
+        auto exec = DayOfWeekExec<Op<std::chrono::milliseconds>, OutType>::Exec;
         DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
         break;
       }
       case TimeUnit::MICRO: {
-        auto exec =
-            DayOfWeekOptionsWithOptions<Op<std::chrono::microseconds>, OutType>::Exec;
+        auto exec = DayOfWeekExec<Op<std::chrono::microseconds>, OutType>::Exec;
         DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
         break;
       }
       case TimeUnit::NANO: {
-        auto exec =
-            DayOfWeekOptionsWithOptions<Op<std::chrono::nanoseconds>, OutType>::Exec;
+        auto exec = DayOfWeekExec<Op<std::chrono::nanoseconds>, OutType>::Exec;
         DCHECK_OK(func->AddKernel({in_type}, out_type, std::move(exec), init));
         break;
       }
@@ -619,8 +619,7 @@ void RegisterScalarTemporal(FunctionRegistry* registry) {
 
   static auto default_day_of_week_options = DayOfWeekOptions::Defaults();
   auto day_of_week = MakeTemporalWithOptions<DayOfWeek, Int64Type>(
-      "day_of_week", &day_of_week_doc, &default_day_of_week_options,
-      DayOfWeekState::Init);
+      "day_of_week", &day_of_week_doc, default_day_of_week_options, DayOfWeekState::Init);
   DCHECK_OK(registry->AddFunction(std::move(day_of_week)));
 
   auto day_of_year = MakeTemporal<DayOfYear, Int64Type>("day_of_year", &day_of_year_doc);
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
index ac03d3727ac..f2e9c12a050 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
@@ -117,51 +117,6 @@ TEST_F(ScalarTemporalTest, TestTemporalComponentExtraction) {
   CheckScalarUnary("microsecond", unit, times, int64(), microsecond);
   CheckScalarUnary("nanosecond", unit, times, int64(), nanosecond);
   CheckScalarUnary("subsecond", unit, times, float64(), subsecond);
-
-  auto timestamps = ArrayFromJSON(unit, times);
-  auto day_of_week_week_start_7_zero_based =
-      "[4, 2, 0, 3, null, 3, 2, 1, 4, 5, 0, 1, 0, 6, 0, 1, 0]";
-  auto day_of_week_week_start_2_zero_based =
-      "[2, 0, 5, 1, null, 1, 0, 6, 2, 3, 5, 6, 5, 4, 5, 6, 5]";
-  auto day_of_week_week_start_7_one_based =
-      "[5, 3, 1, 4, null, 4, 3, 2, 5, 6, 1, 2, 1, 7, 1, 2, 1]";
-  auto day_of_week_week_start_2_one_based =
-      "[3, 1, 6, 2, null, 2, 1, 7, 3, 4, 6, 7, 6, 5, 6, 7, 6]";
-
-  auto expected_70 = ArrayFromJSON(int64(), day_of_week_week_start_7_zero_based);
-  ASSERT_OK_AND_ASSIGN(
-      Datum result_70,
-      DayOfWeek(timestamps, DayOfWeekOptions(
-                                /*one_based_numbering=*/false, /*week_start=*/7)));
-  ASSERT_TRUE(result_70.Equals(expected_70));
-
-  auto expected_20 = ArrayFromJSON(int64(), day_of_week_week_start_2_zero_based);
-  ASSERT_OK_AND_ASSIGN(
-      Datum result_20,
-      DayOfWeek(timestamps, DayOfWeekOptions(
-                                /*one_based_numbering=*/false, /*week_start=*/2)));
-  ASSERT_TRUE(result_20.Equals(expected_20));
-
-  auto expected_71 = ArrayFromJSON(int64(), day_of_week_week_start_7_one_based);
-  ASSERT_OK_AND_ASSIGN(
-      Datum result_71,
-      DayOfWeek(timestamps, DayOfWeekOptions(
-                                /*one_based_numbering=*/true, /*week_start=*/7)));
-  ASSERT_TRUE(result_71.Equals(expected_71));
-
-  auto expected_21 = ArrayFromJSON(int64(), day_of_week_week_start_2_one_based);
-  ASSERT_OK_AND_ASSIGN(
-      Datum result_21,
-      DayOfWeek(timestamps, DayOfWeekOptions(
-                                /*one_based_numbering=*/true, /*week_start=*/2)));
-  ASSERT_TRUE(result_21.Equals(expected_21));
-
-  ASSERT_RAISES(Invalid,
-                DayOfWeek(timestamps, DayOfWeekOptions(/*one_based_numbering=*/true,
-                                                       /*week_start=*/0)));
-  ASSERT_RAISES(Invalid,
-                DayOfWeek(timestamps, DayOfWeekOptions(/*one_based_numbering=*/false,
-                                                       /*week_start=*/8)));
 }
 
 TEST_F(ScalarTemporalTest, TestTemporalComponentExtractionWithDifferentUnits) {
@@ -212,5 +167,54 @@ TEST_F(ScalarTemporalTest, TestZonedTemporalComponentExtraction) {
     ASSERT_RAISES(NotImplemented, Subsecond(timestamps));
   }
 }
+
+TEST_F(ScalarTemporalTest, DayOfWeek) {
+  auto unit = timestamp(TimeUnit::NANO);
+
+  auto timestamps = ArrayFromJSON(unit, times);
+  auto day_of_week_week_start_7_zero_based =
+      "[4, 2, 0, 3, null, 3, 2, 1, 4, 5, 0, 1, 0, 6, 0, 1, 0]";
+  auto day_of_week_week_start_2_zero_based =
+      "[2, 0, 5, 1, null, 1, 0, 6, 2, 3, 5, 6, 5, 4, 5, 6, 5]";
+  auto day_of_week_week_start_7_one_based =
+      "[5, 3, 1, 4, null, 4, 3, 2, 5, 6, 1, 2, 1, 7, 1, 2, 1]";
+  auto day_of_week_week_start_2_one_based =
+      "[3, 1, 6, 2, null, 2, 1, 7, 3, 4, 6, 7, 6, 5, 6, 7, 6]";
+
+  auto expected_70 = ArrayFromJSON(int64(), day_of_week_week_start_7_zero_based);
+  ASSERT_OK_AND_ASSIGN(
+      Datum result_70,
+      DayOfWeek(timestamps, DayOfWeekOptions(
+                                /*one_based_numbering=*/false, /*week_start=*/7)));
+  ASSERT_TRUE(result_70.Equals(expected_70));
+
+  auto expected_20 = ArrayFromJSON(int64(), day_of_week_week_start_2_zero_based);
+  ASSERT_OK_AND_ASSIGN(
+      Datum result_20,
+      DayOfWeek(timestamps, DayOfWeekOptions(
+                                /*one_based_numbering=*/false, /*week_start=*/2)));
+  ASSERT_TRUE(result_20.Equals(expected_20));
+
+  auto expected_71 = ArrayFromJSON(int64(), day_of_week_week_start_7_one_based);
+  ASSERT_OK_AND_ASSIGN(
+      Datum result_71,
+      DayOfWeek(timestamps, DayOfWeekOptions(
+                                /*one_based_numbering=*/true, /*week_start=*/7)));
+  ASSERT_TRUE(result_71.Equals(expected_71));
+
+  auto expected_21 = ArrayFromJSON(int64(), day_of_week_week_start_2_one_based);
+  ASSERT_OK_AND_ASSIGN(
+      Datum result_21,
+      DayOfWeek(timestamps, DayOfWeekOptions(
+                                /*one_based_numbering=*/true, /*week_start=*/2)));
+  ASSERT_TRUE(result_21.Equals(expected_21));
+
+  ASSERT_RAISES(Invalid,
+                DayOfWeek(timestamps, DayOfWeekOptions(/*one_based_numbering=*/true,
+                                                       /*week_start=*/0)));
+  ASSERT_RAISES(Invalid,
+                DayOfWeek(timestamps, DayOfWeekOptions(/*one_based_numbering=*/false,
+                                                       /*week_start=*/8)));
+}
 }  // namespace compute
 }  // namespace arrow
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index a59bd6373cf..6844e7a9ba3 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1027,7 +1027,7 @@ Note: this is currently not supported for timestamps with timezone information.
 * \(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
   the starting day of the week using ISO convention (Monday=1, Sunday=7). Day numbering can start with 0 or 1
-  using :member:`DayOfWeekOptions::week_start` parameter.
+  using :member:`DayOfWeekOptions::one_based_numbering` parameter.
 * \(2) First ISO week has the majority (4 or more) of it's days in January. ISO year
   starts with the first ISO week.
   See `ISO 8601 week date definition`_ for more details.
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 86c8218e67e..1b66f74eb74 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -962,15 +962,10 @@ class StrptimeOptions(_StrptimeOptions):
 
 
 cdef class _DayOfWeekOptions(FunctionOptions):
-    cdef:
-        unique_ptr[CDayOfWeekOptions] day_of_week_options
-
-    cdef const CFunctionOptions* get_options(self) except NULL:
-        return self.day_of_week_options.get()
-
     def _set_options(self, one_based_numbering, week_start):
-        self.day_of_week_options.reset(
-            new CDayOfWeekOptions(one_based_numbering, week_start))
+        self.wrapped.reset(
+            new CDayOfWeekOptions(one_based_numbering, week_start)
+        )
 
 
 class DayOfWeekOptions(_DayOfWeekOptions):
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 3d621aafbbf..37040ec86b5 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -120,6 +120,7 @@ def test_option_class_equality():
         pc.PadOptions(5, " "),
         pc.PartitionNthOptions(1),
         pc.ProjectOptions([b"field", b"names"]),
+        pc.DayOfWeekOptions(False, 0),
         pc.ReplaceSliceOptions(start=0, stop=1, replacement="a"),
         pc.ReplaceSubstringOptions("a", "b"),
         pc.SetLookupOptions(value_set=pa.array([1])),

From 50853df02e2486c342497addfa8699d96a19daae Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Mon, 5 Jul 2021 18:21:09 +0200
Subject: [PATCH 13/15] Apply suggestions from code review.

---
 cpp/src/arrow/compute/kernels/scalar_temporal.cc | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index 0a931c8db27..1e7cb3c785f 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -89,7 +89,7 @@ struct DayOfWeekExec {
   using OutValue = typename internal::GetOutputType<OutType>::T;
 
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
-    DayOfWeekOptions options = DayOfWeekState::Get(ctx);
+    const DayOfWeekOptions& options = DayOfWeekState::Get(ctx);
     if (options.week_start < 1 || 7 < options.week_start) {
       return Status::Invalid(
           "week_start must follow ISO convention (Monday=1, Sunday=7). Got week_start=",
@@ -148,7 +148,7 @@ struct Day {
 
 template <typename Duration>
 struct DayOfWeek {
-  explicit DayOfWeek(DayOfWeekOptions options) : options(options) {
+  explicit DayOfWeek(const DayOfWeekOptions& options) {
     for (int i = 0; i < 7; i++) {
       lookup_table[i] = i + 8 - options.week_start;
       lookup_table[i] = (lookup_table[i] > 6) ? lookup_table[i] - 7 : lookup_table[i];
@@ -165,7 +165,6 @@ struct DayOfWeek {
     return lookup_table[wd - 1];
   }
   std::array<int64_t, 7> lookup_table;
-  DayOfWeekOptions options;
 };
 
 // ----------------------------------------------------------------------

From b797b80915150fd6ec2e723fe0cf44e0a9bae19a Mon Sep 17 00:00:00 2001
From: Rok <rok@mihevc.org>
Date: Tue, 6 Jul 2021 18:41:15 +0200
Subject: [PATCH 14/15] Applying review feedback.

---
 .../arrow/compute/kernels/scalar_temporal.cc  |  1 -
 docs/source/cpp/compute.rst                   | 70 +++++++++----------
 2 files changed, 35 insertions(+), 36 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index 1e7cb3c785f..3947884554b 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -36,7 +36,6 @@ using arrow_vendored::date::days;
 using arrow_vendored::date::floor;
 using arrow_vendored::date::hh_mm_ss;
 using arrow_vendored::date::sys_time;
-using arrow_vendored::date::time_zone;
 using arrow_vendored::date::trunc;
 using arrow_vendored::date::weekday;
 using arrow_vendored::date::weeks;
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 6844e7a9ba3..c1241aceb2a 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -988,41 +988,41 @@ Temporal component extraction
 These functions extract datetime components (year, month, day, etc) from timestamp type.
 Note: this is currently not supported for timestamps with timezone information.
 
-+--------------------+------------+-------------------+---------------+--------+----------------------------+
-| Function name      | Arity      | Input types       | Output type   | Notes  | Options class              |
-+====================+============+===================+===============+========+============================+
-| year               | Unary      | Temporal          | Int64         |        |                            |
-+--------------------+------------+-------------------+---------------+--------+----------------------------+
-| month              | Unary      | Temporal          | Int64         |        |                            |
-+--------------------+------------+-------------------+---------------+--------+----------------------------+
-| day                | Unary      | Temporal          | Int64         |        |                            |
-+--------------------+------------+-------------------+---------------+--------+----------------------------+
-| day_of_week        | Unary      | Temporal          | Int64         | \(1)   | :struct:`DayOfWeekOptions` |
-+--------------------+------------+-------------------+---------------+--------+----------------------------+
-| day_of_year        | Unary      | Temporal          | Int64         |        |                            |
-+--------------------+------------+-------------------+---------------+--------+----------------------------+
-| iso_year           | Unary      | Temporal          | Int64         | \(2)   |                            |
-+--------------------+------------+-------------------+---------------+--------+----------------------------+
-| iso_week           | Unary      | Temporal          | Int64         | \(2)   |                            |
-+--------------------+------------+-------------------+---------------+--------+----------------------------+
-| iso_calendar       | Unary      | Temporal          | Struct        | \(3)   |                            |
-+--------------------+------------+-------------------+---------------+--------+----------------------------+
-| quarter            | Unary      | Temporal          | Int64         |        |                            |
-+--------------------+------------+-------------------+---------------+--------+----------------------------+
-| hour               | Unary      | Temporal          | Int64         |        |                            |
-+--------------------+------------+-------------------+---------------+--------+----------------------------+
-| minute             | Unary      | Temporal          | Int64         |        |                            |
-+--------------------+------------+-------------------+---------------+--------+----------------------------+
-| second             | Unary      | Temporal          | Int64         |        |                            |
-+--------------------+------------+-------------------+---------------+--------+----------------------------+
-| millisecond        | Unary      | Temporal          | Int64         |        |                            |
-+--------------------+------------+-------------------+---------------+--------+----------------------------+
-| microsecond        | Unary      | Temporal          | Int64         |        |                            |
-+--------------------+------------+-------------------+---------------+--------+----------------------------+
-| nanosecond         | Unary      | Temporal          | Int64         |        |                            |
-+--------------------+------------+-------------------+---------------+--------+----------------------------+
-| subsecond          | Unary      | Temporal          | Double        |        |                            |
-+--------------------+------------+-------------------+---------------+--------+----------------------------+
++--------------------+------------+-------------------+---------------+----------------------------+-------+
+| Function name      | Arity      | Input types       | Output type   | Options class              | Notes |
++====================+============+===================+===============+============================+=======+
+| year               | Unary      | Temporal          | Int64         |                            |       |
++--------------------+------------+-------------------+---------------+----------------------------+-------+
+| month              | Unary      | Temporal          | Int64         |                            |       |
++--------------------+------------+-------------------+---------------+----------------------------+-------+
+| day                | Unary      | Temporal          | Int64         |                            |       |
++--------------------+------------+-------------------+---------------+----------------------------+-------+
+| day_of_week        | Unary      | Temporal          | Int64         | :struct:`DayOfWeekOptions` | \(1)  |
++--------------------+------------+-------------------+---------------+----------------------------+-------+
+| day_of_year        | Unary      | Temporal          | Int64         |                            |       |
++--------------------+------------+-------------------+---------------+----------------------------+-------+
+| iso_year           | Unary      | Temporal          | Int64         |                            | \(2)  |
++--------------------+------------+-------------------+---------------+----------------------------+-------+
+| iso_week           | Unary      | Temporal          | Int64         |                            | \(2)  |
++--------------------+------------+-------------------+---------------+----------------------------+-------+
+| iso_calendar       | Unary      | Temporal          | Struct        |                            | \(3)  |
++--------------------+------------+-------------------+---------------+----------------------------+-------+
+| quarter            | Unary      | Temporal          | Int64         |                            |       |
++--------------------+------------+-------------------+---------------+----------------------------+-------+
+| hour               | Unary      | Temporal          | Int64         |                            |       |
++--------------------+------------+-------------------+---------------+----------------------------+-------+
+| minute             | Unary      | Temporal          | Int64         |                            |       |
++--------------------+------------+-------------------+---------------+----------------------------+-------+
+| second             | Unary      | Temporal          | Int64         |                            |       |
++--------------------+------------+-------------------+---------------+----------------------------+-------+
+| millisecond        | Unary      | Temporal          | Int64         |                            |       |
++--------------------+------------+-------------------+---------------+----------------------------+-------+
+| microsecond        | Unary      | Temporal          | Int64         |                            |       |
++--------------------+------------+-------------------+---------------+----------------------------+-------+
+| nanosecond         | Unary      | Temporal          | Int64         |                            |       |
++--------------------+------------+-------------------+---------------+----------------------------+-------+
+| subsecond          | Unary      | Temporal          | Double        |                            |       |
++--------------------+------------+-------------------+---------------+----------------------------+-------+
 
 * \(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

From 7c2aa2e0310efcf4bdd8545d3ee7cde9b7d458e1 Mon Sep 17 00:00:00 2001
From: Rok Mihevc <rok@mihevc.org>
Date: Tue, 6 Jul 2021 18:43:23 +0200
Subject: [PATCH 15/15] Update cpp/src/arrow/compute/kernels/scalar_temporal.cc

Co-authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 cpp/src/arrow/compute/kernels/scalar_temporal.cc | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
index 3947884554b..f0257772d4a 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal.cc
@@ -524,8 +524,7 @@ const FunctionDoc day_doc{
 const FunctionDoc day_of_week_doc{
     "Extract day of the week number",
     ("By default, the week starts on Monday represented by 0 and ends on Sunday "
-     "represented "
-     "by 6.\n"
+     "represented by 6.\n"
      "DayOfWeekOptions.week_start can be used to set another starting day using ISO "
      "convention (Monday=1, Sunday=7). Day numbering can start with 0 or 1 using "
      "DayOfWeekOptions.one_based_numbering parameter.\n"