[EXP] GH-44792: [C++] Require C++20

.github/workflows/cpp.yml

@@ -290,7 +290,7 @@ jobs:
         include:
           - os: windows-2022
             simd-level: AVX2
-            title: AMD64 Windows 2022 AVX2
+            title: AMD64 Windows 2022 C++20 AVX2
     env:
       ARROW_BOOST_USE_SHARED: OFF
       ARROW_BUILD_BENCHMARKS: ON
@@ -317,7 +317,7 @@ jobs:
       ARROW_WITH_ZLIB: ON
       ARROW_WITH_ZSTD: ON
       BOOST_SOURCE: BUNDLED
-      CMAKE_CXX_STANDARD: "17"
+      CMAKE_CXX_STANDARD: "20"
       CMAKE_GENERATOR: Ninja
       CMAKE_INSTALL_LIBDIR: bin
       CMAKE_INSTALL_PREFIX: /usr

.github/workflows/r.yml

@@ -286,12 +286,13 @@ jobs:
           # static library. The R is not used here but R 4.1 was the last R to use
           # Rtools40.
           r-version: "4.1"
-          rtools-version: 40
+          rtools-version: ${{ matrix.config.rtools }}
           Ncpus: 2
       - name: Build Arrow C++
         shell: bash
         env:
           MINGW_ARCH: ${{ matrix.config.arch }}
+          RTOOLS_VERSION: ${{ matrix.config.rtools }}
         run: ci/scripts/r_windows_build.sh
       - name: Rename libarrow.zip
         # So that they're unique when multiple are downloaded in the next step

.github/workflows/ruby.yml

@@ -349,7 +349,7 @@ jobs:
       ARROW_WITH_SNAPPY: ON
       ARROW_WITH_ZLIB: ON
       ARROW_WITH_ZSTD: ON
-      CMAKE_CXX_STANDARD: "17"
+      CMAKE_CXX_STANDARD: "20"
       CMAKE_GENERATOR: Ninja
       CMAKE_INSTALL_PREFIX: "${{ github.workspace }}/dist"
       VCPKG_BINARY_SOURCES: 'clear;nuget,GitHub,readwrite'

c_glib/meson.build

@@ -21,7 +21,7 @@ project(
     'arrow-glib',
     'c',
     'cpp',
-    default_options: ['c_std=c99', 'cpp_std=c++17'],
+    default_options: ['c_std=c99', 'cpp_std=c++20'],
     license: 'Apache-2.0',
     # Debian:
     #   https://packages.debian.org/search?keywords=meson

ci/appveyor-cpp-build.bat

@@ -93,7 +93,7 @@ cmake -G "%GENERATOR%" %ARROW_CMAKE_ARGS% ^
       -DARROW_WITH_ZSTD=ON ^
       -DCMAKE_BUILD_TYPE="Release" ^
       -DCMAKE_CXX_FLAGS_RELEASE="/MD /Od /UNDEBUG" ^
-      -DCMAKE_CXX_STANDARD=17 ^
+      -DCMAKE_CXX_STANDARD=20 ^
       -DCMAKE_INSTALL_PREFIX=%CONDA_PREFIX%\Library ^
       -DCMAKE_UNITY_BUILD=ON ^
       -DCMAKE_VERBOSE_MAKEFILE=OFF ^

ci/docker/centos-7-cpp.dockerfile

@@ -25,7 +25,7 @@ RUN sed -i \
       -e 's/mirror\.centos\.org/vault.centos.org/' \
       /etc/yum.repos.d/*.repo
 
-# devtoolset is required for C++17
+# devtoolset is required for C++20
 RUN \
   yum install -y \
     centos-release-scl \
@@ -38,7 +38,8 @@ RUN \
     /etc/yum.repos.d/CentOS-SCLo-scl*.repo && \
   yum install -y \
     curl \
-    devtoolset-8 \
+    devtoolset-11-gcc-c++ \
+    devtoolset-11-make \
     diffutils \
     gcc-c++ \
     libcurl-devel \

ci/scripts/cpp_build.sh

@@ -167,7 +167,7 @@ elif [ "${ARROW_EMSCRIPTEN:-OFF}" = "ON" ]; then
     -DCMAKE_VERBOSE_MAKEFILE=${CMAKE_VERBOSE_MAKEFILE:-OFF} \
     -DCMAKE_C_FLAGS="${CFLAGS:-}" \
     -DCMAKE_CXX_FLAGS="${CXXFLAGS:-}" \
-    -DCMAKE_CXX_STANDARD="${CMAKE_CXX_STANDARD:-17}" \
+    -DCMAKE_CXX_STANDARD="${CMAKE_CXX_STANDARD:-20}" \
     -DCMAKE_INSTALL_LIBDIR=${CMAKE_INSTALL_LIBDIR:-lib} \
     -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX:-${ARROW_HOME}} \
     -DCMAKE_UNITY_BUILD=${CMAKE_UNITY_BUILD:-OFF} \
@@ -255,7 +255,7 @@ else
     -DCMAKE_VERBOSE_MAKEFILE=${CMAKE_VERBOSE_MAKEFILE:-OFF} \
     -DCMAKE_C_FLAGS="${CFLAGS:-}" \
     -DCMAKE_CXX_FLAGS="${CXXFLAGS:-}" \
-    -DCMAKE_CXX_STANDARD="${CMAKE_CXX_STANDARD:-17}" \
+    -DCMAKE_CXX_STANDARD="${CMAKE_CXX_STANDARD:-20}" \
     -DCMAKE_INSTALL_LIBDIR=${CMAKE_INSTALL_LIBDIR:-lib} \
     -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX:-${ARROW_HOME}} \
     -DCMAKE_UNITY_BUILD=${CMAKE_UNITY_BUILD:-OFF} \

ci/scripts/r_windows_build.sh

@@ -44,7 +44,7 @@ mv mingw* build
 cd build
 
 # This may vary by system/CI provider
-MSYS_LIB_DIR="/c/rtools40"
+MSYS_LIB_DIR="/c/rtools${RTOOLS_VERSION}"
 
 # Untar the builds we made
 ls *.xz | xargs -n 1 tar -xJf

cpp/CMakeLists.txt

@@ -625,10 +625,10 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ARROW_CXXFLAGS}")
 # C++ specific flags.
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CXX_COMMON_FLAGS} ${ARROW_CXXFLAGS}")
 
-# Remove --std=c++17 to avoid errors from C compilers
-string(REPLACE "-std=c++17" "" CMAKE_C_FLAGS ${CMAKE_C_FLAGS})
+# Remove -std=c++20 to avoid errors from C compilers
+string(REPLACE "-std=c++20" "" CMAKE_C_FLAGS ${CMAKE_C_FLAGS})
 
-# Add C++-only flags, like -std=c++17
+# Add C++-only flags, like -std=c++20
 set(CMAKE_CXX_FLAGS "${CXX_ONLY_FLAGS} ${CMAKE_CXX_FLAGS}")
 
 # ASAN / TSAN / UBSAN

cpp/cmake_modules/GandivaAddBitcode.cmake

@@ -17,7 +17,7 @@
 
 # Create bitcode for the given source file.
 function(gandiva_add_bitcode SOURCE)
-  set(CLANG_OPTIONS -std=c++17)
+  set(CLANG_OPTIONS -std=c++20)
   if(MSVC)
     # "19.20" means that it's compatible with Visual Studio 16 2019.
     # We can update this to "19.30" when we dropped support for Visual

cpp/cmake_modules/SetupCxxFlags.cmake

@@ -137,12 +137,12 @@ endif()
 
 # This ensures that things like c++17 get passed correctly
 if(NOT DEFINED CMAKE_CXX_STANDARD)
-  set(CMAKE_CXX_STANDARD 17)
-elseif(${CMAKE_CXX_STANDARD} VERSION_LESS 17)
-  message(FATAL_ERROR "Cannot set a CMAKE_CXX_STANDARD smaller than 17")
+  set(CMAKE_CXX_STANDARD 20)
+elseif(${CMAKE_CXX_STANDARD} VERSION_LESS 20)
+  message(FATAL_ERROR "Cannot set a CMAKE_CXX_STANDARD smaller than 20")
 endif()
 
-# We require a C++17 compliant compiler
+# We require a C++20 compliant compiler
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 # ARROW-6848: Do not use GNU (or other CXX) extensions

cpp/examples/minimal_build/CMakeLists.txt

@@ -24,10 +24,10 @@ option(ARROW_LINK_SHARED "Link to the Arrow shared library" ON)
 find_package(Arrow REQUIRED)
 
 if(NOT DEFINED CMAKE_CXX_STANDARD)
-  set(CMAKE_CXX_STANDARD 17)
+  set(CMAKE_CXX_STANDARD 20)
 endif()
 
-# We require a C++17 compliant compiler
+# We require a C++20 compliant compiler
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 if(NOT CMAKE_BUILD_TYPE)

cpp/examples/minimal_build/run_static.sh

@@ -86,7 +86,7 @@ echo
 
 rm -rf $EXAMPLE_BUILD_DIR
 mkdir -p $EXAMPLE_BUILD_DIR
-${CXX:-c++} -std=c++17 \
+${CXX:-c++} -std=c++20 \
   -o $EXAMPLE_BUILD_DIR/arrow-example \
   $EXAMPLE_DIR/example.cc \
   $(PKG_CONFIG_PATH=$ARROW_BUILD_DIR/lib/pkgconfig \

cpp/examples/parquet/parquet_arrow/CMakeLists.txt

@@ -28,10 +28,10 @@ option(PARQUET_LINK_SHARED "Link to the Parquet shared library" ON)
 
 # This ensures that things like -std=gnu++... get passed correctly
 if(NOT DEFINED CMAKE_CXX_STANDARD)
-  set(CMAKE_CXX_STANDARD 17)
+  set(CMAKE_CXX_STANDARD 20)
 endif()
 
-# We require a C++17 compliant compiler
+# We require a C++20 compliant compiler
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 # Look for installed packages the system

cpp/examples/tutorial_examples/CMakeLists.txt

@@ -21,7 +21,7 @@ project(ArrowTutorialExamples)
 
 find_package(ArrowDataset)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wall -Wextra")
 
 set(CMAKE_BUILD_TYPE Release)

cpp/meson.build

@@ -26,7 +26,7 @@ project(
         'buildtype=release',
         'c_std=c99',
         'warning_level=2',
-        'cpp_std=c++17',
+        'cpp_std=c++20',
     ],
 )
 

cpp/src/arrow/array/array_nested.cc

@@ -17,10 +17,10 @@
 
 #include "arrow/array/array_nested.h"
 
-#include <atomic>
 #include <cstddef>
 #include <cstdint>
 #include <memory>
+#include <mutex>
 #include <string>
 #include <utility>
 #include <vector>
@@ -1004,10 +1004,18 @@ Result<std::shared_ptr<Array>> FixedSizeListArray::Flatten(
 // ----------------------------------------------------------------------
 // Struct
 
+struct StructArray::Impl {
+  std::mutex mutex;
+  ArrayVector boxed_fields;
+};
+
+StructArray::~StructArray() = default;
+
 StructArray::StructArray(const std::shared_ptr<ArrayData>& data) {
   ARROW_CHECK_EQ(data->type->id(), Type::STRUCT);
   SetData(data);
-  boxed_fields_.resize(data->child_data.size());
+  impl_ = std::make_unique<Impl>();
+  impl_->boxed_fields.resize(data_->child_data.size());
 }
 
 StructArray::StructArray(const std::shared_ptr<DataType>& type, int64_t length,
@@ -1016,10 +1024,12 @@ StructArray::StructArray(const std::shared_ptr<DataType>& type, int64_t length,
                          int64_t offset) {
   ARROW_CHECK_EQ(type->id(), Type::STRUCT);
   SetData(ArrayData::Make(type, length, {std::move(null_bitmap)}, null_count, offset));
+  data_->child_data.reserve(children.size());
   for (const auto& child : children) {
     data_->child_data.push_back(child->data());
   }
-  boxed_fields_.resize(children.size());
+  impl_ = std::make_unique<Impl>();
+  impl_->boxed_fields.resize(data_->child_data.size());
 }
 
 Result<std::shared_ptr<StructArray>> StructArray::Make(
@@ -1069,27 +1079,32 @@ const StructType* StructArray::struct_type() const {
   return checked_cast<const StructType*>(data_->type.get());
 }
 
+std::shared_ptr<Array> StructArray::MakeBoxedField(int i) const {
+  std::shared_ptr<ArrayData> field_data;
+  if (data_->offset != 0 || data_->child_data[i]->length != data_->length) {
+    field_data = data_->child_data[i]->Slice(data_->offset, data_->length);
+  } else {
+    field_data = data_->child_data[i];
+  }
+  return MakeArray(field_data);
+}
+
 const ArrayVector& StructArray::fields() const {
+  std::lock_guard lock(impl_->mutex);
   for (int i = 0; i < num_fields(); ++i) {
-    (void)field(i);
+    if (impl_->boxed_fields[i] == nullptr) {
+      impl_->boxed_fields[i] = MakeBoxedField(i);
+    }
   }
-  return boxed_fields_;
+  return impl_->boxed_fields;
 }
 
 const std::shared_ptr<Array>& StructArray::field(int i) const {
-  std::shared_ptr<Array> result = std::atomic_load(&boxed_fields_[i]);
-  if (!result) {
-    std::shared_ptr<ArrayData> field_data;
-    if (data_->offset != 0 || data_->child_data[i]->length != data_->length) {
-      field_data = data_->child_data[i]->Slice(data_->offset, data_->length);
-    } else {
-      field_data = data_->child_data[i];
-    }
-    result = MakeArray(field_data);
-    std::atomic_store(&boxed_fields_[i], std::move(result));
-    return boxed_fields_[i];
+  std::lock_guard lock(impl_->mutex);
+  if (impl_->boxed_fields[i] == nullptr) {
+    impl_->boxed_fields[i] = MakeBoxedField(i);
   }
-  return boxed_fields_[i];
+  return impl_->boxed_fields[i];
 }
 
 std::shared_ptr<Array> StructArray::GetFieldByName(const std::string& name) const {
@@ -1177,14 +1192,24 @@ Result<std::shared_ptr<Array>> StructArray::GetFlattenedField(int index,
 // ----------------------------------------------------------------------
 // UnionArray
 
+struct UnionArray::Impl {
+  std::mutex mutex;
+  ArrayVector boxed_fields;
+};
+
+UnionArray::UnionArray() = default;
+UnionArray::~UnionArray() = default;
+
 void UnionArray::SetData(std::shared_ptr<ArrayData> data) {
   this->Array::SetData(std::move(data));
 
   union_type_ = checked_cast<const UnionType*>(data_->type.get());
 
   ARROW_CHECK_GE(data_->buffers.size(), 2);
   raw_type_codes_ = data->GetValuesSafe<int8_t>(1);
-  boxed_fields_.resize(data_->child_data.size());
+
+  impl_ = std::make_unique<Impl>();
+  impl_->boxed_fields.resize(data_->child_data.size());
 }
 
 void SparseUnionArray::SetData(std::shared_ptr<ArrayData> data) {
@@ -1198,16 +1223,16 @@ void SparseUnionArray::SetData(std::shared_ptr<ArrayData> data) {
 
 void DenseUnionArray::SetData(const std::shared_ptr<ArrayData>& data) {
   this->UnionArray::SetData(data);
-
   ARROW_CHECK_EQ(data_->type->id(), Type::DENSE_UNION);
   ARROW_CHECK_EQ(data_->buffers.size(), 3);
 
   // No validity bitmap
   ARROW_CHECK_EQ(data_->buffers[0], nullptr);
-
   raw_value_offsets_ = data->GetValuesSafe<int32_t>(2);
 }
 
+SparseUnionArray::~SparseUnionArray() = default;
+
 SparseUnionArray::SparseUnionArray(std::shared_ptr<ArrayData> data) {
   SetData(std::move(data));
 }
@@ -1261,6 +1286,8 @@ Result<std::shared_ptr<Array>> SparseUnionArray::GetFlattenedField(
   return MakeArray(child_data);
 }
 
+DenseUnionArray::~DenseUnionArray() = default;
+
 DenseUnionArray::DenseUnionArray(const std::shared_ptr<ArrayData>& data) {
   SetData(data);
 }
@@ -1352,26 +1379,29 @@ Result<std::shared_ptr<Array>> SparseUnionArray::Make(
   return std::make_shared<SparseUnionArray>(std::move(internal_data));
 }
 
+std::shared_ptr<Array> UnionArray::MakeBoxedField(int i) const {
+  std::shared_ptr<ArrayData> child_data = data_->child_data[i]->Copy();
+  if (mode() == UnionMode::SPARSE) {
+    // Sparse union: need to adjust child if union is sliced
+    // (for dense unions, the need to lookup through the offsets
+    //  makes this unnecessary)
+    if (data_->offset != 0 || child_data->length > data_->length) {
+      child_data = child_data->Slice(data_->offset, data_->length);
+    }
+  }
+  return MakeArray(child_data);
+}
+
 std::shared_ptr<Array> UnionArray::field(int i) const {
-  if (i < 0 ||
-      static_cast<decltype(boxed_fields_)::size_type>(i) >= boxed_fields_.size()) {
+  if (i < 0 || i >= num_fields()) {
     return nullptr;
   }
-  std::shared_ptr<Array> result = std::atomic_load(&boxed_fields_[i]);
-  if (!result) {
-    std::shared_ptr<ArrayData> child_data = data_->child_data[i]->Copy();
-    if (mode() == UnionMode::SPARSE) {
-      // Sparse union: need to adjust child if union is sliced
-      // (for dense unions, the need to lookup through the offsets
-      //  makes this unnecessary)
-      if (data_->offset != 0 || child_data->length > data_->length) {
-        child_data = child_data->Slice(data_->offset, data_->length);
-      }
-    }
-    result = MakeArray(child_data);
-    std::atomic_store(&boxed_fields_[i], result);
+
+  std::lock_guard lock(impl_->mutex);
+  if (impl_->boxed_fields[i] == nullptr) {
+    impl_->boxed_fields[i] = MakeBoxedField(i);
   }
-  return result;
+  return impl_->boxed_fields[i];
 }
 
 }  // namespace arrow