diff --git a/.clang-format b/.clang-format
index 06453dfbb25..9448dc8d8c8 100644
--- a/.clang-format
+++ b/.clang-format
@@ -15,6 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 ---
-BasedOnStyle:  Google
-DerivePointerAlignment: false
+BasedOnStyle: Google
 ColumnLimit: 90
+DerivePointerAlignment: false
+IncludeBlocks: Preserve
diff --git a/.env b/.env
index 43cfefccee4..7dcfa306bf0 100644
--- a/.env
+++ b/.env
@@ -29,47 +29,63 @@ DOCKER_VOLUME_PREFIX=
 
 # turn on inline build cache, this is a docker buildx feature documented
 # at https://github.com/docker/buildx#--cache-tonametypetypekeyvalue
+BUILDKIT_INLINE_CACHE=1
 COMPOSE_DOCKER_CLI_BUILD=1
 DOCKER_BUILDKIT=1
-BUILDKIT_INLINE_CACHE=1
 
 # different architecture notations
 ARCH=amd64
 ARCH_ALIAS=x86_64
-ARCH_SHORT_ALIAS=x64
+ARCH_SHORT=amd64
 
-ULIMIT_CORE=-1
+# Default repository to pull and push images from
 REPO=apache/arrow-dev
-CUDA=9.1
+
+# The setup attempts to generate coredumps by default, in order to disable the
+# coredump generation set it to 0
+ULIMIT_CORE=-1
+
+# Default versions for platforms
 DEBIAN=11
-UBUNTU=20.04
 FEDORA=33
-PYTHON=3.6
-LLVM=12
-CLANG_TOOLS=8
+UBUNTU=20.04
+
+# Default versions for various dependencies
+CLANG_TOOLS=12
+CUDA=9.1
+DASK=latest
+DOTNET=3.1
+GCC_VERSION=""
 GO=1.15
-NODE=14
-MAVEN=3.5.4
+HDFS=3.2.1
 JDK=8
+KARTOTHEK=latest
+LLVM=12
+MAVEN=3.5.4
+NODE=14
 NUMPY=latest
 PANDAS=latest
-DASK=latest
-TURBODBC=latest
-KARTOTHEK=latest
-HDFS=3.2.1
-SPARK=master
-DOTNET=3.1
+PYTHON=3.6
 R=4.1
-ARROW_R_DEV=TRUE
-GCC_VERSION=""
+SPARK=master
+TURBODBC=latest
+
 # These correspond to images on Docker Hub that contain R, e.g. rhub/ubuntu-gcc-release:latest
-R_ORG=rhub
+ARROW_R_DEV=TRUE
 R_IMAGE=ubuntu-gcc-release
+R_ORG=rhub
+R_PRUNE_DEPS=FALSE
 R_TAG=latest
 TZ=UTC
+
 # -1 does not attempt to install a devtoolset version, any positive integer will install devtoolset-n
 DEVTOOLSET_VERSION=-1
 
-# Used for the manylinux and windows wheels, please update the crossbow configuration on update:
+# Used through docker-compose.yml and serves as the default version for the
+# ci/scripts/install_vcpkg.sh script. Prefer to use short SHAs to keep the
+# docker tags more readable.
+#
+# Please also update the crossbow configuration in order to keep the github
+# actions cache up to date for the macOS wheels:
 #   https://github.com/ursacomputing/crossbow/blob/master/.github/workflows/cache_vcpkg.yml
-VCPKG="2021.04.30"
+VCPKG="30465138e"
diff --git a/.github/workflows/cpp.yml b/.github/workflows/cpp.yml
index 9a374ebf282..468b3ea8687 100644
--- a/.github/workflows/cpp.yml
+++ b/.github/workflows/cpp.yml
@@ -108,7 +108,11 @@ jobs:
         uses: actions/checkout@v2
         with:
           fetch-depth: 0
-      - name: Run
+      - name: Check CMake presets
+        run: |
+          cd cpp
+          cmake --list-presets
+      - name: Run minimal example
         run: |
           cd cpp/examples/minimal_build
           docker-compose run --rm minimal
@@ -178,7 +182,7 @@ jobs:
           ci/scripts/cpp_test.sh $(pwd) $(pwd)/build
 
   windows:
-    name: AMD64 ${{ matrix.name }} C++
+    name: AMD64 ${{ matrix.name }} C++17
     runs-on: ${{ matrix.os }}
     if: ${{ !contains(github.event.pull_request.title, 'WIP') }}
     timeout-minutes: 45
@@ -197,6 +201,7 @@ jobs:
       ARROW_BUILD_SHARED: ON
       ARROW_BUILD_STATIC: OFF
       ARROW_BUILD_TESTS: ON
+      ARROW_CXXFLAGS: "/std:c++17"
       ARROW_DATASET: ON
       ARROW_FLIGHT: OFF
       ARROW_HDFS: ON
@@ -218,7 +223,7 @@ jobs:
       CMAKE_INSTALL_LIBDIR: bin
       CMAKE_INSTALL_PREFIX: /usr
       CMAKE_UNITY_BUILD: ON
-      NPROC: 2
+      NPROC: 3
     steps:
       - name: Disable Crash Dialogs
         run: |
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
new file mode 100644
index 00000000000..19bebedb46e
--- /dev/null
+++ b/.github/workflows/docs.yml
@@ -0,0 +1,77 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+name: Docs
+
+on:
+  push:
+  pull_request:
+    paths:
+      - '.github/workflows/docs.yml'
+      - 'ci/docker/linux-apt-docs.dockerfile'
+      - 'ci/docker/linux-apt-python-3.dockerfile'
+      - 'ci/docker/ubuntu-20.04-cpp.dockerfile'
+      - 'ci/scripts/c_glib_build.sh'
+      - 'ci/scripts/cpp_build.sh'
+      - 'ci/scripts/docs_build.sh'
+      - 'ci/scripts/java_build.sh'
+      - 'ci/scripts/js_build.sh'
+      - 'ci/scripts/python_build.sh'
+      - 'ci/scripts/r_build.sh'
+
+env:
+  ARROW_ENABLE_TIMING_TESTS: OFF
+  DOCKER_VOLUME_PREFIX: ".docker/"
+  ARCHERY_DOCKER_USER: ${{ secrets.DOCKERHUB_USER }}
+  ARCHERY_DOCKER_PASSWORD: ${{ secrets.DOCKERHUB_TOKEN }}
+
+jobs:
+
+  docker:
+    name: AMD64 Ubuntu 20.04 Complete Documentation
+    runs-on: ubuntu-latest
+    if: ${{ !contains(github.event.pull_request.title, 'WIP') }}
+    timeout-minutes: 150
+    env:
+      UBUNTU: "20.04"
+    steps:
+      - name: Checkout Arrow
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - name: Fetch Submodules and Tags
+        run: ci/scripts/util_checkout.sh
+      - name: Free Up Disk Space
+        run: ci/scripts/util_cleanup.sh
+      - name: Cache Docker Volumes
+        uses: actions/cache@v2
+        with:
+          path: .docker
+          key: ubuntu-docs-${{ hashFiles('cpp/**') }}
+          restore-keys: ubuntu-docs-
+      - name: Setup Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.8
+      - name: Setup Archery
+        run: pip install -e dev/archery[docker]
+      - name: Execute Docker Build
+        run: archery docker run ubuntu-docs
+      - name: Docker Push
+        if: success() && github.event_name == 'push' && github.repository == 'apache/arrow'
+        continue-on-error: true
+        run: archery docker push ubuntu-docs
diff --git a/.github/workflows/ruby.yml b/.github/workflows/ruby.yml
index 2afb7532318..5e861ecf2cf 100644
--- a/.github/workflows/ruby.yml
+++ b/.github/workflows/ruby.yml
@@ -58,7 +58,7 @@ jobs:
     name: AMD64 Ubuntu ${{ matrix.ubuntu }} GLib & Ruby
     runs-on: ubuntu-latest
     if: ${{ !contains(github.event.pull_request.title, 'WIP') }}
-    timeout-minutes: 40
+    timeout-minutes: 60
     strategy:
       fail-fast: false
       matrix:
diff --git a/c_glib/arrow-glib/basic-data-type.cpp b/c_glib/arrow-glib/basic-data-type.cpp
index 888b7143fbf..114e884212c 100644
--- a/c_glib/arrow-glib/basic-data-type.cpp
+++ b/c_glib/arrow-glib/basic-data-type.cpp
@@ -78,6 +78,9 @@ G_BEGIN_DECLS
  * #GArrowLargeStringDataType is a class for the 64-bit offsets UTF-8
  * encoded string data type.
  *
+ * #GArrowTemporalDataType is an abstract class for temporal related data type
+ * such as #GArrowDate32DataType.
+ *
  * #GArrowDate32DataType is a class for the number of days since UNIX
  * epoch in the 32-bit signed integer data type.
  *
@@ -975,9 +978,24 @@ garrow_large_string_data_type_new(void)
 }
 
 
+G_DEFINE_ABSTRACT_TYPE(GArrowTemporalDataType,
+                       garrow_temporal_data_type,
+                       GARROW_TYPE_FIXED_WIDTH_DATA_TYPE)
+
+static void
+garrow_temporal_data_type_init(GArrowTemporalDataType *object)
+{
+}
+
+static void
+garrow_temporal_data_type_class_init(GArrowTemporalDataTypeClass *klass)
+{
+}
+
+
 G_DEFINE_TYPE(GArrowDate32DataType,
               garrow_date32_data_type,
-              GARROW_TYPE_DATA_TYPE)
+              GARROW_TYPE_TEMPORAL_DATA_TYPE)
 
 static void
 garrow_date32_data_type_init(GArrowDate32DataType *object)
@@ -1012,7 +1030,7 @@ garrow_date32_data_type_new(void)
 
 G_DEFINE_TYPE(GArrowDate64DataType,
               garrow_date64_data_type,
-              GARROW_TYPE_DATA_TYPE)
+              GARROW_TYPE_TEMPORAL_DATA_TYPE)
 
 static void
 garrow_date64_data_type_init(GArrowDate64DataType *object)
@@ -1047,7 +1065,7 @@ garrow_date64_data_type_new(void)
 
 G_DEFINE_TYPE(GArrowTimestampDataType,
               garrow_timestamp_data_type,
-              GARROW_TYPE_DATA_TYPE)
+              GARROW_TYPE_TEMPORAL_DATA_TYPE)
 
 static void
 garrow_timestamp_data_type_init(GArrowTimestampDataType *object)
@@ -1102,7 +1120,7 @@ garrow_timestamp_data_type_get_unit(GArrowTimestampDataType *timestamp_data_type
 
 G_DEFINE_ABSTRACT_TYPE(GArrowTimeDataType,
                        garrow_time_data_type,
-                       GARROW_TYPE_DATA_TYPE)
+                       GARROW_TYPE_TEMPORAL_DATA_TYPE)
 
 static void
 garrow_time_data_type_init(GArrowTimeDataType *object)
diff --git a/c_glib/arrow-glib/basic-data-type.h b/c_glib/arrow-glib/basic-data-type.h
index b498583e265..7dca40f7377 100644
--- a/c_glib/arrow-glib/basic-data-type.h
+++ b/c_glib/arrow-glib/basic-data-type.h
@@ -357,15 +357,27 @@ GARROW_AVAILABLE_IN_0_17
 GArrowLargeStringDataType *garrow_large_string_data_type_new(void);
 
 
+#define GARROW_TYPE_TEMPORAL_DATA_TYPE (garrow_temporal_data_type_get_type())
+G_DECLARE_DERIVABLE_TYPE(GArrowTemporalDataType,
+                         garrow_temporal_data_type,
+                         GARROW,
+                         TEMPORAL_DATA_TYPE,
+                         GArrowFixedWidthDataType)
+struct _GArrowTemporalDataTypeClass
+{
+  GArrowFixedWidthDataTypeClass parent_class;
+};
+
+
 #define GARROW_TYPE_DATE32_DATA_TYPE (garrow_date32_data_type_get_type())
 G_DECLARE_DERIVABLE_TYPE(GArrowDate32DataType,
                          garrow_date32_data_type,
                          GARROW,
                          DATE32_DATA_TYPE,
-                         GArrowDataType)
+                         GArrowTemporalDataType)
 struct _GArrowDate32DataTypeClass
 {
-  GArrowDataTypeClass parent_class;
+  GArrowTemporalDataTypeClass parent_class;
 };
 
 GArrowDate32DataType *garrow_date32_data_type_new      (void);
@@ -376,10 +388,10 @@ G_DECLARE_DERIVABLE_TYPE(GArrowDate64DataType,
                          garrow_date64_data_type,
                          GARROW,
                          DATE64_DATA_TYPE,
-                         GArrowDataType)
+                         GArrowTemporalDataType)
 struct _GArrowDate64DataTypeClass
 {
-  GArrowDataTypeClass parent_class;
+  GArrowTemporalDataTypeClass parent_class;
 };
 
 GArrowDate64DataType *garrow_date64_data_type_new      (void);
@@ -390,10 +402,10 @@ G_DECLARE_DERIVABLE_TYPE(GArrowTimestampDataType,
                          garrow_timestamp_data_type,
                          GARROW,
                          TIMESTAMP_DATA_TYPE,
-                         GArrowDataType)
+                         GArrowTemporalDataType)
 struct _GArrowTimestampDataTypeClass
 {
-  GArrowDataTypeClass parent_class;
+  GArrowTemporalDataTypeClass parent_class;
 };
 
 GArrowTimestampDataType *garrow_timestamp_data_type_new   (GArrowTimeUnit unit);
@@ -406,10 +418,10 @@ G_DECLARE_DERIVABLE_TYPE(GArrowTimeDataType,
                          garrow_time_data_type,
                          GARROW,
                          TIME_DATA_TYPE,
-                         GArrowDataType)
+                         GArrowTemporalDataType)
 struct _GArrowTimeDataTypeClass
 {
-  GArrowDataTypeClass parent_class;
+  GArrowTemporalDataTypeClass parent_class;
 };
 
 GArrowTimeUnit garrow_time_data_type_get_unit (GArrowTimeDataType *time_data_type);
diff --git a/ci/appveyor-cpp-setup.bat b/ci/appveyor-cpp-setup.bat
index cee9bc28e5f..00f4dff0ac9 100644
--- a/ci/appveyor-cpp-setup.bat
+++ b/ci/appveyor-cpp-setup.bat
@@ -43,6 +43,11 @@ conda config --set remote_connect_timeout_secs 12
 conda config --append disallowed_packages pypy3
 conda info -a
 
+@rem
+@rem Install mamba to the base environment
+@rem
+conda install -q -y -c conda-forge mamba
+
 @rem
 @rem Create conda environment for Build and Toolchain jobs
 @rem
@@ -60,7 +65,7 @@ if "%JOB%" == "Toolchain" (
 )
 if "%JOB%" NEQ "Build_Debug" (
   @rem Arrow conda environment is only required for the Build and Toolchain jobs
-  conda create -n arrow -q -y -c conda-forge ^
+  mamba create -n arrow -q -y -c conda-forge ^
     --file=ci\conda_env_python.txt ^
     %CONDA_PACKAGES%  ^
     "cmake=3.17" ^
@@ -74,7 +79,7 @@ if "%JOB%" NEQ "Build_Debug" (
   @rem On Windows, GTest is always bundled from source instead of using
   @rem conda binaries, avoid any interference between the two versions.
   if "%JOB%" == "Toolchain" (
-    conda uninstall -n arrow -q -y -c conda-forge gtest
+    mamba uninstall -n arrow -q -y -c conda-forge gtest
   )
 )
 
diff --git a/ci/conda_env_cpp.txt b/ci/conda_env_cpp.txt
index 6d1ebf35341..cd7136cebbd 100644
--- a/ci/conda_env_cpp.txt
+++ b/ci/conda_env_cpp.txt
@@ -16,7 +16,7 @@
 # under the License.
 
 aws-sdk-cpp
-benchmark>=1.5.4
+benchmark>=1.6.0
 boost-cpp>=1.68.0
 brotli
 bzip2
diff --git a/ci/conda_env_sphinx.txt b/ci/conda_env_sphinx.txt
index ca82705e73c..9f6c99b132e 100644
--- a/ci/conda_env_sphinx.txt
+++ b/ci/conda_env_sphinx.txt
@@ -19,6 +19,9 @@
 breathe
 doxygen
 ipython
-sphinx=4.2
+sphinx>=4.2
 pydata-sphinx-theme
-sphinx-tabs
+
+# Unable to install sphinx-tabs from conda-forge due to:
+# - package sphinx-tabs-1.2.1-py_0 requires sphinx >=2,<4, but none of the providers can be installed
+# sphinx-tabs
diff --git a/ci/docker/conda-cpp.dockerfile b/ci/docker/conda-cpp.dockerfile
index 40a855b5dd2..8fd5e46fd6d 100644
--- a/ci/docker/conda-cpp.dockerfile
+++ b/ci/docker/conda-cpp.dockerfile
@@ -19,17 +19,23 @@ ARG repo
 ARG arch
 FROM ${repo}:${arch}-conda
 
+COPY ci/scripts/install_minio.sh /arrow/ci/scripts
+RUN /arrow/ci/scripts/install_minio.sh latest /opt/conda
+
+COPY ci/scripts/install_gcs_testbench.sh /arrow/ci/scripts
+RUN /arrow/ci/scripts/install_gcs_testbench.sh default
+
 # install the required conda packages into the test environment
 COPY ci/conda_env_cpp.txt \
      ci/conda_env_gandiva.txt \
      /arrow/ci/
-RUN conda install \
+RUN mamba install \
         --file arrow/ci/conda_env_cpp.txt \
         --file arrow/ci/conda_env_gandiva.txt \
         compilers \
         doxygen \
         valgrind && \
-    conda clean --all
+    mamba clean --all
 
 ENV ARROW_BUILD_TESTS=ON \
     ARROW_DATASET=ON \
diff --git a/ci/docker/conda-integration.dockerfile b/ci/docker/conda-integration.dockerfile
index d40973330a6..378fe71df70 100644
--- a/ci/docker/conda-integration.dockerfile
+++ b/ci/docker/conda-integration.dockerfile
@@ -27,7 +27,7 @@ ARG go=1.15
 
 # Install Archery and integration dependencies
 COPY ci/conda_env_archery.txt /arrow/ci/
-RUN conda install -q \
+RUN mamba install -q \
         --file arrow/ci/conda_env_archery.txt \
         "python>=3.7" \
         numpy \
@@ -36,7 +36,7 @@ RUN conda install -q \
         nodejs=${node} \
         yarn \
         openjdk=${jdk} && \
-    conda clean --all --force-pkgs-dirs
+    mamba clean --all --force-pkgs-dirs
 
 # Install Rust with only the needed components
 # (rustfmt is needed for tonic-build to compile the protobuf definitions)
diff --git a/ci/docker/conda-python-hdfs.dockerfile b/ci/docker/conda-python-hdfs.dockerfile
index f6ffc71ce62..65a1befa64c 100644
--- a/ci/docker/conda-python-hdfs.dockerfile
+++ b/ci/docker/conda-python-hdfs.dockerfile
@@ -22,11 +22,11 @@ FROM ${repo}:${arch}-conda-python-${python}
 
 ARG jdk=8
 ARG maven=3.5
-RUN conda install -q \
+RUN mamba install -q \
         maven=${maven} \
         openjdk=${jdk} \
         pandas && \
-    conda clean --all
+    mamba clean --all
 
 # installing libhdfs (JNI)
 ARG hdfs=3.2.1
diff --git a/ci/docker/conda-python-jpype.dockerfile b/ci/docker/conda-python-jpype.dockerfile
index f77ef9bf66b..005007e2c4d 100644
--- a/ci/docker/conda-python-jpype.dockerfile
+++ b/ci/docker/conda-python-jpype.dockerfile
@@ -22,8 +22,8 @@ FROM ${repo}:${arch}-conda-python-${python}
 
 ARG jdk=11
 ARG maven=3.6
-RUN conda install -q \
+RUN mamba install -q \
         maven=${maven} \
         openjdk=${jdk} \
         jpype1 && \
-    conda clean --all
+    mamba clean --all
diff --git a/ci/docker/conda-python-kartothek.dockerfile b/ci/docker/conda-python-kartothek.dockerfile
index d523161822c..77dd1f5214f 100644
--- a/ci/docker/conda-python-kartothek.dockerfile
+++ b/ci/docker/conda-python-kartothek.dockerfile
@@ -21,12 +21,13 @@ ARG python=3.6
 FROM ${repo}:${arch}-conda-python-${python}
 
 # install kartothek dependencies from conda-forge
-RUN conda install -c conda-forge -q \
+RUN mamba install -c conda-forge -q \
         attrs \
         click \
         cloudpickle \
         dask \
         decorator \
+        deprecation \
         freezegun \
         msgpack-python \
         prompt-toolkit \
@@ -39,7 +40,7 @@ RUN conda install -c conda-forge -q \
         toolz \
         urlquote \
         zstandard && \
-    conda clean --all
+    mamba clean --all
 
 ARG kartothek=latest
 COPY ci/scripts/install_kartothek.sh /arrow/ci/scripts/
diff --git a/ci/docker/conda-python-pandas.dockerfile b/ci/docker/conda-python-pandas.dockerfile
index 303cc80e48a..9f1ba099116 100644
--- a/ci/docker/conda-python-pandas.dockerfile
+++ b/ci/docker/conda-python-pandas.dockerfile
@@ -23,5 +23,5 @@ FROM ${repo}:${arch}-conda-python-${python}
 ARG pandas=latest
 ARG numpy=latest
 COPY ci/scripts/install_pandas.sh /arrow/ci/scripts/
-RUN conda uninstall -q -y numpy && \
+RUN mamba uninstall -q -y numpy && \
     /arrow/ci/scripts/install_pandas.sh ${pandas} ${numpy}
diff --git a/ci/docker/conda-python-spark.dockerfile b/ci/docker/conda-python-spark.dockerfile
index a2af2ac135c..233a1fc363f 100644
--- a/ci/docker/conda-python-spark.dockerfile
+++ b/ci/docker/conda-python-spark.dockerfile
@@ -23,11 +23,11 @@ FROM ${repo}:${arch}-conda-python-${python}
 ARG jdk=8
 ARG maven=3.5
 
-RUN conda install -q \
+RUN mamba install -q \
         openjdk=${jdk} \
         maven=${maven} \
         pandas && \
-    conda clean --all
+    mamba clean --all
 
 # installing specific version of spark
 ARG spark=master
diff --git a/ci/docker/conda-python-turbodbc.dockerfile b/ci/docker/conda-python-turbodbc.dockerfile
index e748604dee3..e702cd13524 100644
--- a/ci/docker/conda-python-turbodbc.dockerfile
+++ b/ci/docker/conda-python-turbodbc.dockerfile
@@ -30,12 +30,12 @@ RUN export DEBIAN_FRONTEND=noninteractive && \
     rm -rf /var/lib/apt/lists/*
 
 # install turbodbc dependencies from conda-forge
-RUN conda install -c conda-forge -q \
+RUN mamba install -c conda-forge -q \
         pybind11 \
         pytest-cov \
         mock \
         unixodbc && \
-    conda clean --all
+    mamba clean --all
 
 RUN service postgresql start && \
     sudo -u postgres psql -U postgres -c \
diff --git a/ci/docker/conda-python.dockerfile b/ci/docker/conda-python.dockerfile
index ab3f77be1b6..ae7abd9c9db 100644
--- a/ci/docker/conda-python.dockerfile
+++ b/ci/docker/conda-python.dockerfile
@@ -21,13 +21,20 @@ FROM ${repo}:${arch}-conda-cpp
 
 # install python specific packages
 ARG python=3.6
-COPY ci/conda_env_python.txt /arrow/ci/
-RUN conda install -q \
+COPY ci/conda_env_python.txt \
+     ci/conda_env_sphinx.txt \
+     /arrow/ci/
+RUN mamba install -q \
         --file arrow/ci/conda_env_python.txt \
+        --file arrow/ci/conda_env_sphinx.txt \
         $([ "$python" == "3.6" -o "$python" == "3.7" ] && echo "pickle5") \
         python=${python} \
         nomkl && \
-    conda clean --all
+    mamba clean --all
+
+# unable to install from conda-forge due to sphinx version pin, see comment in
+# arrow/ci/conda_env_sphinx.txt
+RUN pip install sphinx-tabs
 
 ENV ARROW_PYTHON=ON \
     ARROW_BUILD_STATIC=OFF \
diff --git a/ci/docker/conda.dockerfile b/ci/docker/conda.dockerfile
index adb64f9fad0..d0545e3bf84 100644
--- a/ci/docker/conda.dockerfile
+++ b/ci/docker/conda.dockerfile
@@ -18,10 +18,6 @@
 ARG arch=amd64
 FROM ${arch}/ubuntu:18.04
 
-# arch is unset after the FROM statement, so need to define it again
-ARG arch=amd64
-ARG prefix=/opt/conda
-
 # install build essentials
 RUN export DEBIAN_FRONTEND=noninteractive && \
     apt-get update -y -q && \
@@ -29,27 +25,22 @@ RUN export DEBIAN_FRONTEND=noninteractive && \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
-ENV PATH=${prefix}/bin:$PATH
-# install conda and minio
-COPY ci/scripts/install_conda.sh \
-     ci/scripts/install_minio.sh \
-     /arrow/ci/scripts/
-RUN /arrow/ci/scripts/install_conda.sh ${arch} linux latest ${prefix}
-RUN /arrow/ci/scripts/install_minio.sh ${arch} linux latest ${prefix}
-COPY ci/scripts/install_gcs_testbench.sh /arrow/ci/scripts
-RUN /arrow/ci/scripts/install_gcs_testbench.sh ${arch} default
+# install conda and mamba via mambaforge
+COPY ci/scripts/install_conda.sh /arrow/ci/scripts/
+RUN /arrow/ci/scripts/install_conda.sh mambaforge latest /opt/conda
+ENV PATH=/opt/conda/bin:$PATH
 
 # create a conda environment
 ADD ci/conda_env_unix.txt /arrow/ci/
-RUN conda create -n arrow --file arrow/ci/conda_env_unix.txt git && \
-    conda clean --all
+RUN mamba create -n arrow --file arrow/ci/conda_env_unix.txt git && \
+    mamba clean --all
 
 # activate the created environment by default
 RUN echo "conda activate arrow" >> ~/.profile
-ENV CONDA_PREFIX=${prefix}/envs/arrow
+ENV CONDA_PREFIX=/opt/conda/envs/arrow
 
 # use login shell to activate arrow environment un the RUN commands
-SHELL [ "/bin/bash", "-c", "-l" ]
+SHELL ["/bin/bash", "-c", "-l"]
 
 # use login shell when running the container
-ENTRYPOINT [ "/bin/bash", "-c", "-l" ]
+ENTRYPOINT ["/bin/bash", "-c", "-l"]
diff --git a/ci/docker/debian-10-cpp.dockerfile b/ci/docker/debian-10-cpp.dockerfile
index f85408f0348..2bb9e88a711 100644
--- a/ci/docker/debian-10-cpp.dockerfile
+++ b/ci/docker/debian-10-cpp.dockerfile
@@ -17,7 +17,6 @@
 
 ARG arch=amd64
 FROM ${arch}/debian:10
-ARG arch
 
 ENV DEBIAN_FRONTEND noninteractive
 
@@ -67,13 +66,14 @@ RUN apt-get update -y -q && \
         protobuf-compiler \
         python3-pip \
         rapidjson-dev \
+        rsync \
         tzdata \
         zlib1g-dev && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/*
 
 COPY ci/scripts/install_minio.sh /arrow/ci/scripts/
-RUN /arrow/ci/scripts/install_minio.sh ${arch} linux latest /usr/local
+RUN /arrow/ci/scripts/install_minio.sh latest /usr/local
 
 ENV ARROW_BUILD_TESTS=ON \
     ARROW_DATASET=ON \
diff --git a/ci/docker/debian-10-js.dockerfile b/ci/docker/debian-10-js.dockerfile
index 5bb31f2e32e..f994de4141d 100644
--- a/ci/docker/debian-10-js.dockerfile
+++ b/ci/docker/debian-10-js.dockerfile
@@ -21,6 +21,12 @@ FROM ${arch}/node:${node}
 
 ENV NODE_NO_WARNINGS=1
 
+# install rsync for copying the generated documentation
+RUN apt-get update -y -q && \
+    apt-get install -y -q --no-install-recommends rsync && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
 # TODO(kszucs):
 # 1. add the files required to install the dependencies to .dockerignore
 # 2. copy these files to their appropriate path
diff --git a/ci/docker/debian-11-cpp.dockerfile b/ci/docker/debian-11-cpp.dockerfile
index 659881b0c8b..c2b0e98d9fc 100644
--- a/ci/docker/debian-11-cpp.dockerfile
+++ b/ci/docker/debian-11-cpp.dockerfile
@@ -65,15 +65,17 @@ RUN apt-get update -y -q && \
         protobuf-compiler-grpc \
         python3-pip \
         rapidjson-dev \
+        rsync \
         tzdata \
         zlib1g-dev && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/*
 
 COPY ci/scripts/install_minio.sh /arrow/ci/scripts/
-RUN /arrow/ci/scripts/install_minio.sh ${arch} linux latest /usr/local
+RUN /arrow/ci/scripts/install_minio.sh latest /usr/local
+
 COPY ci/scripts/install_gcs_testbench.sh /arrow/ci/scripts/
-RUN /arrow/ci/scripts/install_gcs_testbench.sh ${arch} default
+RUN /arrow/ci/scripts/install_gcs_testbench.sh default
 
 ENV ARROW_BUILD_TESTS=ON \
     ARROW_DATASET=ON \
diff --git a/ci/docker/debian-11-js.dockerfile b/ci/docker/debian-11-js.dockerfile
index 5bb31f2e32e..f994de4141d 100644
--- a/ci/docker/debian-11-js.dockerfile
+++ b/ci/docker/debian-11-js.dockerfile
@@ -21,6 +21,12 @@ FROM ${arch}/node:${node}
 
 ENV NODE_NO_WARNINGS=1
 
+# install rsync for copying the generated documentation
+RUN apt-get update -y -q && \
+    apt-get install -y -q --no-install-recommends rsync && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
 # TODO(kszucs):
 # 1. add the files required to install the dependencies to .dockerignore
 # 2. copy these files to their appropriate path
diff --git a/ci/docker/fedora-33-cpp.dockerfile b/ci/docker/fedora-33-cpp.dockerfile
index 61964a476e9..a60a572ec3a 100644
--- a/ci/docker/fedora-33-cpp.dockerfile
+++ b/ci/docker/fedora-33-cpp.dockerfile
@@ -64,9 +64,10 @@ RUN dnf update -y && \
         zlib-devel
 
 COPY ci/scripts/install_minio.sh /arrow/ci/scripts/
-RUN /arrow/ci/scripts/install_minio.sh ${arch} linux latest /usr/local
+RUN /arrow/ci/scripts/install_minio.sh latest /usr/local
+
 COPY ci/scripts/install_gcs_testbench.sh /arrow/ci/scripts/
-RUN /arrow/ci/scripts/install_gcs_testbench.sh ${arch} default
+RUN /arrow/ci/scripts/install_gcs_testbench.sh default
 
 ENV ARROW_BUILD_TESTS=ON \
     ARROW_DEPENDENCY_SOURCE=SYSTEM \
diff --git a/ci/docker/linux-apt-docs.dockerfile b/ci/docker/linux-apt-docs.dockerfile
index 12c797f9651..3cd62a23d7d 100644
--- a/ci/docker/linux-apt-docs.dockerfile
+++ b/ci/docker/linux-apt-docs.dockerfile
@@ -27,9 +27,8 @@ RUN apt-get update -y && \
         dirmngr \
         apt-transport-https \
         software-properties-common && \
-    apt-key adv \
-        --keyserver keyserver.ubuntu.com \
-        --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9 && \
+    wget -qO- https://cloud.r-project.org/bin/linux/ubuntu/marutter_pubkey.asc | \
+        tee -a /etc/apt/trusted.gpg.d/cran_ubuntu_key.asc && \
     add-apt-repository 'deb https://cloud.r-project.org/bin/linux/ubuntu '$(lsb_release -cs)'-cran40/' && \
     apt-get install -y --no-install-recommends \
         autoconf-archive \
@@ -75,14 +74,13 @@ RUN wget -q -O - https://deb.nodesource.com/setup_${node}.x | bash - && \
     rm -rf /var/lib/apt/lists/* && \
     npm install -g yarn
 
-# ARROW-13353: breathe >= 4.29.1 tries to parse template arguments,
-# but Sphinx can't parse constructs like `typename...`.
 RUN pip install \
-        meson \
-        breathe==4.29.0 \
+        breathe \
         ipython \
-        sphinx \
-        pydata-sphinx-theme
+        meson \
+        pydata-sphinx-theme \
+        sphinx-tabs \
+        sphinx>=4.2
 
 COPY c_glib/Gemfile /arrow/c_glib/
 RUN gem install --no-document bundler && \
@@ -107,4 +105,4 @@ ENV ARROW_FLIGHT=ON \
     ARROW_BUILD_TESTS=OFF \
     ARROW_BUILD_UTILITIES=OFF \
     ARROW_USE_GLOG=OFF \
-    CMAKE_UNITY_BUILD=ON \
+    CMAKE_UNITY_BUILD=ON
diff --git a/ci/docker/linux-apt-lint.dockerfile b/ci/docker/linux-apt-lint.dockerfile
index 84de6b05f31..a92aa276f9a 100644
--- a/ci/docker/linux-apt-lint.dockerfile
+++ b/ci/docker/linux-apt-lint.dockerfile
@@ -41,9 +41,8 @@ RUN apt-get update && \
     && rm -rf /var/lib/apt/lists/*
 
 ARG r=4.1
-RUN apt-key adv \
-        --keyserver keyserver.ubuntu.com \
-        --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9 && \
+RUN wget -qO- https://cloud.r-project.org/bin/linux/ubuntu/marutter_pubkey.asc | \
+        tee -a /etc/apt/trusted.gpg.d/cran_ubuntu_key.asc && \
     # NOTE: R 3.5 and 3.6 are available in the repos with -cran35 suffix
     # for trusty, xenial, bionic, and eoan (as of May 2020)
     # -cran40 has 4.0 versions for bionic and focal
diff --git a/ci/docker/linux-apt-r.dockerfile b/ci/docker/linux-apt-r.dockerfile
index 894f53bc0a3..8e290dc00e0 100644
--- a/ci/docker/linux-apt-r.dockerfile
+++ b/ci/docker/linux-apt-r.dockerfile
@@ -17,7 +17,6 @@
 
 ARG base
 FROM ${base}
-ARG arch
 
 ARG tz="UTC"
 ENV TZ=${tz}
@@ -34,9 +33,8 @@ RUN apt-get update -y && \
         dirmngr \
         apt-transport-https \
         software-properties-common && \
-    apt-key adv \
-        --keyserver keyserver.ubuntu.com \
-        --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9 && \
+    wget -qO- https://cloud.r-project.org/bin/linux/ubuntu/marutter_pubkey.asc | \
+        tee -a /etc/apt/trusted.gpg.d/cran_ubuntu_key.asc && \
     # NOTE: R 3.5 and 3.6 are available in the repos with -cran35 suffix
     # for trusty, xenial, bionic, and eoan (as of May 2020)
     # -cran40 has 4.0 versions for bionic and focal
@@ -84,18 +82,19 @@ RUN cat /arrow/ci/etc/rprofile >> $(R RHOME)/etc/Rprofile.site
 # Also ensure parallel compilation of C/C++ code
 RUN echo "MAKEFLAGS=-j$(R -s -e 'cat(parallel::detectCores())')" >> $(R RHOME)/etc/Renviron.site
 
+# Set up Python 3 and its dependencies
+RUN ln -s /usr/bin/python3 /usr/local/bin/python && \
+    ln -s /usr/bin/pip3 /usr/local/bin/pip
+
 COPY ci/scripts/r_deps.sh /arrow/ci/scripts/
 COPY r/DESCRIPTION /arrow/r/
 RUN /arrow/ci/scripts/r_deps.sh /arrow
 
 COPY ci/scripts/install_minio.sh /arrow/ci/scripts/
-RUN /arrow/ci/scripts/install_minio.sh ${arch} linux latest /usr/local
-COPY ci/scripts/install_gcs_testbench.sh /arrow/ci/scripts/
-RUN /arrow/ci/scripts/install_gcs_testbench.sh ${arch} default
+RUN /arrow/ci/scripts/install_minio.sh latest /usr/local
 
-# Set up Python 3 and its dependencies
-RUN ln -s /usr/bin/python3 /usr/local/bin/python && \
-    ln -s /usr/bin/pip3 /usr/local/bin/pip
+COPY ci/scripts/install_gcs_testbench.sh /arrow/ci/scripts/
+RUN /arrow/ci/scripts/install_gcs_testbench.sh default
 
 COPY python/requirements-build.txt /arrow/python/
 RUN pip install -r arrow/python/requirements-build.txt
diff --git a/ci/docker/linux-r.dockerfile b/ci/docker/linux-r.dockerfile
index ca701e259c4..1cbde3207ed 100644
--- a/ci/docker/linux-r.dockerfile
+++ b/ci/docker/linux-r.dockerfile
@@ -46,6 +46,10 @@ COPY ci/scripts/install_minio.sh /arrow/ci/scripts/
 COPY ci/scripts/install_gcs_testbench.sh /arrow/ci/scripts/
 RUN /arrow/ci/scripts/r_docker_configure.sh
 
+# Set up Python 3 and its dependencies
+RUN ln -s /usr/bin/python3 /usr/local/bin/python && \
+    ln -s /usr/bin/pip3 /usr/local/bin/pip
+
 COPY ci/scripts/r_deps.sh /arrow/ci/scripts/
 COPY r/DESCRIPTION /arrow/r/
 RUN /arrow/ci/scripts/r_deps.sh /arrow
diff --git a/ci/docker/python-wheel-manylinux-201x.dockerfile b/ci/docker/python-wheel-manylinux-201x.dockerfile
index ae1b0a7767c..dee2b1244b1 100644
--- a/ci/docker/python-wheel-manylinux-201x.dockerfile
+++ b/ci/docker/python-wheel-manylinux-201x.dockerfile
@@ -18,56 +18,54 @@
 ARG base
 FROM ${base}
 
-ARG arch_alias
-ARG arch_short_alias
+ARG arch
+ARG arch_short
+ARG manylinux
 
+ENV MANYLINUX_VERSION=${manylinux}
+
+# Install basic dependencies
 RUN yum install -y git flex curl autoconf zip wget
 
 # Install CMake
-ARG cmake=3.19.3
-RUN wget -q https://github.com/Kitware/CMake/releases/download/v${cmake}/cmake-${cmake}-Linux-${arch_alias}.tar.gz -O - | \
-    tar -xzf - --directory /usr/local --strip-components=1
+# AWS SDK doesn't work with CMake=3.22 due to https://gitlab.kitware.com/cmake/cmake/-/issues/22524
+ARG cmake=3.21.4
+COPY ci/scripts/install_cmake.sh arrow/ci/scripts/
+RUN /arrow/ci/scripts/install_cmake.sh ${arch} linux ${cmake} /usr/local
 
 # Install Ninja
 ARG ninja=1.10.2
-RUN mkdir /tmp/ninja && \
-    wget -q https://github.com/ninja-build/ninja/archive/v${ninja}.tar.gz -O - | \
-    tar -xzf - --directory /tmp/ninja --strip-components=1 && \
-    cd /tmp/ninja && \
-    ./configure.py --bootstrap && \
-    mv ninja /usr/local/bin && \
-    rm -rf /tmp/ninja
+COPY ci/scripts/install_ninja.sh arrow/ci/scripts/
+RUN /arrow/ci/scripts/install_ninja.sh ${ninja} /usr/local
 
 # Install ccache
 ARG ccache=4.1
-RUN mkdir /tmp/ccache && \
-    wget -q https://github.com/ccache/ccache/archive/v${ccache}.tar.gz -O - | \
-    tar -xzf - --directory /tmp/ccache --strip-components=1 && \
-    cd /tmp/ccache && \
-    mkdir build && \
-    cd build && \
-    cmake -GNinja -DCMAKE_BUILD_TYPE=Release -DZSTD_FROM_INTERNET=ON .. && \
-    ninja install && \
-    rm -rf /tmp/ccache
+COPY ci/scripts/install_ccache.sh arrow/ci/scripts/
+RUN /arrow/ci/scripts/install_ccache.sh ${ccache} /usr/local
 
-# Install vcpkg
+# Install vcpkg and in case of manylinux2010 install a more recent glibc>2.15
+# for the prebuilt vcpkg binary
 ARG vcpkg
-RUN git clone https://github.com/microsoft/vcpkg /opt/vcpkg && \
-    git -C /opt/vcpkg checkout ${vcpkg} && \
-    /opt/vcpkg/bootstrap-vcpkg.sh -useSystemBinaries -disableMetrics && \
-    ln -s /opt/vcpkg/vcpkg /usr/bin/vcpkg
-
-# Patch ports files as needed
+ARG glibc=2.18
 COPY ci/vcpkg/*.patch \
      ci/vcpkg/*linux*.cmake \
      arrow/ci/vcpkg/
-RUN cd /opt/vcpkg && git apply --ignore-whitespace /arrow/ci/vcpkg/ports.patch
+COPY ci/scripts/install_vcpkg.sh \
+     ci/scripts/install_glibc.sh \
+     arrow/ci/scripts/
+RUN arrow/ci/scripts/install_vcpkg.sh /opt/vcpkg ${vcpkg} && \
+    if [ "${manylinux}" == "2010" ]; then \
+        arrow/ci/scripts/install_glibc.sh ${glibc} /opt/glibc-${glibc} && \
+        patchelf --set-interpreter /opt/glibc-2.18/lib/ld-linux-x86-64.so.2 /opt/vcpkg/vcpkg && \
+        patchelf --set-rpath /opt/glibc-2.18/lib:/usr/lib64 /opt/vcpkg/vcpkg; \
+    fi
+ENV PATH="/opt/vcpkg:${PATH}"
 
 ARG build_type=release
 ENV CMAKE_BUILD_TYPE=${build_type} \
     VCPKG_FORCE_SYSTEM_BINARIES=1 \
     VCPKG_OVERLAY_TRIPLETS=/arrow/ci/vcpkg \
-    VCPKG_DEFAULT_TRIPLET=${arch_short_alias}-linux-static-${build_type} \
+    VCPKG_DEFAULT_TRIPLET=${arch_short}-linux-static-${build_type} \
     VCPKG_FEATURE_FLAGS=-manifests
 
 # Need to install the boost-build prior installing the boost packages, otherwise
@@ -75,8 +73,6 @@ ENV CMAKE_BUILD_TYPE=${build_type} \
 # TODO(kszucs): factor out the package enumeration to a text file and reuse it
 # from the windows image and potentially in a future macos wheel build
 RUN vcpkg install --clean-after-build \
-        boost-build:${arch_short_alias}-linux && \
-    vcpkg install --clean-after-build \
         abseil \
         aws-sdk-cpp[config,cognito-identity,core,identity-management,s3,sts,transfer] \
         boost-filesystem \
@@ -87,6 +83,7 @@ RUN vcpkg install --clean-after-build \
         flatbuffers \
         gflags \
         glog \
+        google-cloud-cpp[core,storage] \
         grpc \
         lz4 \
         openssl \
diff --git a/ci/docker/python-wheel-windows-vs2017.dockerfile b/ci/docker/python-wheel-windows-vs2017.dockerfile
index 9a2afb781fa..e7ff011629b 100644
--- a/ci/docker/python-wheel-windows-vs2017.dockerfile
+++ b/ci/docker/python-wheel-windows-vs2017.dockerfile
@@ -17,7 +17,7 @@
 
 # based on mcr.microsoft.com/windows/servercore:ltsc2019
 # contains choco and vs2017 preinstalled
-FROM abrarov/msvc-2017:2.10.0
+FROM abrarov/msvc-2017:2.12.1
 
 # Install CMake and Ninja
 RUN choco install --no-progress -r -y cmake --installargs 'ADD_CMAKE_TO_PATH=System' && \
@@ -31,16 +31,12 @@ RUN setx path "%path%;C:\Program Files\Git\usr\bin"
 # Compiling vcpkg itself from a git tag doesn't work anymore since vcpkg has
 # started to ship precompiled binaries for the vcpkg-tool.
 ARG vcpkg
-RUN git clone https://github.com/Microsoft/vcpkg && \
-    vcpkg\bootstrap-vcpkg.bat -disableMetrics && \
-    setx PATH "%PATH%;C:\vcpkg" && \
-    git -C vcpkg checkout %vcpkg%
-
-# Patch ports files as needed
 COPY ci/vcpkg/*.patch \
      ci/vcpkg/*windows*.cmake \
      arrow/ci/vcpkg/
-RUN cd vcpkg && git apply --ignore-whitespace C:/arrow/ci/vcpkg/ports.patch
+COPY ci/scripts/install_vcpkg.sh arrow/ci/scripts/
+RUN bash arrow/ci/scripts/install_vcpkg.sh /c/vcpkg %vcpkg% && \
+    setx PATH "%PATH%;C:\vcpkg"
 
 # Configure vcpkg and install dependencies
 # NOTE: use windows batch environment notation for build arguments in RUN
@@ -50,7 +46,7 @@ RUN cd vcpkg && git apply --ignore-whitespace C:/arrow/ci/vcpkg/ports.patch
 ARG build_type=release
 ENV CMAKE_BUILD_TYPE=${build_type} \
     VCPKG_OVERLAY_TRIPLETS=C:\\arrow\\ci\\vcpkg \
-    VCPKG_DEFAULT_TRIPLET=x64-windows-static-md-${build_type} \
+    VCPKG_DEFAULT_TRIPLET=amd64-windows-static-md-${build_type} \
     VCPKG_FEATURE_FLAGS=-manifests
 
 RUN vcpkg install --clean-after-build \
@@ -66,6 +62,7 @@ RUN vcpkg install --clean-after-build \
         flatbuffers \
         gflags \
         glog \
+        google-cloud-cpp[core,storage] \
         grpc \
         lz4 \
         openssl \
diff --git a/ci/docker/ubuntu-18.04-cpp.dockerfile b/ci/docker/ubuntu-18.04-cpp.dockerfile
index 0c05ac4ee6b..d3023f33794 100644
--- a/ci/docker/ubuntu-18.04-cpp.dockerfile
+++ b/ci/docker/ubuntu-18.04-cpp.dockerfile
@@ -83,6 +83,7 @@ RUN apt-get update -y -q && \
         pkg-config \
         protobuf-compiler \
         rapidjson-dev \
+        rsync \
         tzdata && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists*
diff --git a/ci/docker/ubuntu-20.04-cpp-minimal.dockerfile b/ci/docker/ubuntu-20.04-cpp-minimal.dockerfile
index d7076b45bab..f6ca6190559 100644
--- a/ci/docker/ubuntu-20.04-cpp-minimal.dockerfile
+++ b/ci/docker/ubuntu-20.04-cpp-minimal.dockerfile
@@ -17,7 +17,6 @@
 
 ARG base=amd64/ubuntu:20.04
 FROM ${base}
-ARG arch
 
 SHELL ["/bin/bash", "-o", "pipefail", "-c"]
 
@@ -38,9 +37,10 @@ RUN apt-get update -y -q && \
     rm -rf /var/lib/apt/lists*
 
 COPY ci/scripts/install_minio.sh /arrow/ci/scripts/
-RUN /arrow/ci/scripts/install_minio.sh ${arch} linux latest /usr/local
+RUN /arrow/ci/scripts/install_minio.sh latest /usr/local
+
 COPY ci/scripts/install_gcs_testbench.sh /arrow/ci/scripts/
-RUN /arrow/ci/scripts/install_gcs_testbench.sh ${arch} default
+RUN /arrow/ci/scripts/install_gcs_testbench.sh default
 
 ENV ARROW_BUILD_TESTS=ON \
     ARROW_DATASET=ON \
diff --git a/ci/docker/ubuntu-20.04-cpp.dockerfile b/ci/docker/ubuntu-20.04-cpp.dockerfile
index 5a48c648e3b..842be8ddbde 100644
--- a/ci/docker/ubuntu-20.04-cpp.dockerfile
+++ b/ci/docker/ubuntu-20.04-cpp.dockerfile
@@ -17,7 +17,6 @@
 
 ARG base=amd64/ubuntu:20.04
 FROM ${base}
-ARG arch
 
 SHELL ["/bin/bash", "-o", "pipefail", "-c"]
 
@@ -30,20 +29,27 @@ RUN echo "debconf debconf/frontend select Noninteractive" | \
 # while debugging package list with docker build.
 ARG clang_tools
 ARG llvm
-RUN if [ "${llvm}" -gt "10" ]; then \
+RUN latest_system_llvm=10 && \
+    if [ ${llvm} -gt ${latest_system_llvm} -o \
+         ${clang_tools} -gt ${latest_system_llvm} ]; then \
       apt-get update -y -q && \
       apt-get install -y -q --no-install-recommends \
           apt-transport-https \
           ca-certificates \
           gnupg \
+          lsb-release \
           wget && \
       wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add - && \
-      echo "deb https://apt.llvm.org/focal/ llvm-toolchain-focal-${llvm} main" > \
-         /etc/apt/sources.list.d/llvm.list && \
-      if [ "${clang_tools}" != "${llvm}" -a "${clang_tools}" -gt 10 ]; then \
-        echo "deb https://apt.llvm.org/focal/ llvm-toolchain-focal-${clang_tools} main" > \
+      code_name=$(lsb_release --codename --short) && \
+      if [ ${llvm} -gt 10 ]; then \
+        echo "deb https://apt.llvm.org/${code_name}/ llvm-toolchain-${code_name}-${llvm} main" > \
+           /etc/apt/sources.list.d/llvm.list; \
+      fi && \
+      if [ ${clang_tools} -ne ${llvm} -a \
+           ${clang_tools} -gt ${latest_system_llvm} ]; then \
+        echo "deb https://apt.llvm.org/${code_name}/ llvm-toolchain-${code_name}-${clang_tools} main" > \
            /etc/apt/sources.list.d/clang-tools.list; \
-      fi \
+      fi; \
     fi && \
     apt-get update -y -q && \
     apt-get install -y -q --no-install-recommends \
@@ -93,15 +99,18 @@ RUN apt-get update -y -q && \
         python3-rados \
         rados-objclass-dev \
         rapidjson-dev \
+        rsync \
         tzdata \
         wget && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists*
 
 COPY ci/scripts/install_minio.sh /arrow/ci/scripts/
-RUN /arrow/ci/scripts/install_minio.sh ${arch} linux latest /usr/local
+RUN /arrow/ci/scripts/install_minio.sh latest /usr/local
+
 COPY ci/scripts/install_gcs_testbench.sh /arrow/ci/scripts/
-RUN /arrow/ci/scripts/install_gcs_testbench.sh ${arch} default
+RUN /arrow/ci/scripts/install_gcs_testbench.sh default
+
 COPY ci/scripts/install_ceph.sh /arrow/ci/scripts/
 RUN /arrow/ci/scripts/install_ceph.sh
 
diff --git a/ci/docker/ubuntu-20.10-cpp.dockerfile b/ci/docker/ubuntu-20.10-cpp.dockerfile
deleted file mode 100644
index 59f5fa4c886..00000000000
--- a/ci/docker/ubuntu-20.10-cpp.dockerfile
+++ /dev/null
@@ -1,140 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-ARG base=amd64/ubuntu:20.10
-FROM ${base}
-ARG arch
-
-SHELL ["/bin/bash", "-o", "pipefail", "-c"]
-
-RUN echo "debconf debconf/frontend select Noninteractive" | \
-        debconf-set-selections
-
-# Installs LLVM toolchain, for Gandiva and testing other compilers
-#
-# Note that this is installed before the base packages to improve iteration
-# while debugging package list with docker build.
-ARG clang_tools
-ARG llvm
-RUN if [ "${llvm}" -gt "10" ]; then \
-      apt-get update -y -q && \
-      apt-get install -y -q --no-install-recommends \
-          apt-transport-https \
-          ca-certificates \
-          gnupg \
-          wget && \
-      wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add - && \
-      echo "deb https://apt.llvm.org/groovy/ llvm-toolchain-groovy-${llvm} main" > \
-         /etc/apt/sources.list.d/llvm.list && \
-      if [ "${clang_tools}" != "${llvm}" -a "${clang_tools}" -gt 10 ]; then \
-        echo "deb https://apt.llvm.org/groovy/ llvm-toolchain-groovy-${clang_tools} main" > \
-           /etc/apt/sources.list.d/clang-tools.list; \
-      fi \
-    fi && \
-    apt-get update -y -q && \
-    apt-get install -y -q --no-install-recommends \
-        clang-${clang_tools} \
-        clang-${llvm} \
-        clang-format-${clang_tools} \
-        clang-tidy-${clang_tools} \
-        llvm-${llvm}-dev && \
-    apt-get clean && \
-    rm -rf /var/lib/apt/lists*
-
-# Installs C++ toolchain and dependencies
-RUN apt-get update -y -q && \
-    apt-get install -y -q --no-install-recommends \
-        autoconf \
-        ca-certificates \
-        ccache \
-        cmake \
-        g++ \
-        gcc \
-        gdb \
-        git \
-        libbenchmark-dev \
-        libboost-filesystem-dev \
-        libboost-system-dev \
-        libbrotli-dev \
-        libbz2-dev \
-        libc-ares-dev \
-        libcurl4-openssl-dev \
-        libgflags-dev \
-        libgoogle-glog-dev \
-        libgrpc++-dev \
-        liblz4-dev \
-        libprotobuf-dev \
-        libprotoc-dev \
-        libre2-dev \
-        libsnappy-dev \
-        libssl-dev \
-        libthrift-dev \
-        libutf8proc-dev \
-        libzstd-dev \
-        make \
-        ninja-build \
-        pkg-config \
-        protobuf-compiler \
-        protobuf-compiler-grpc \
-        python3-pip \
-        rapidjson-dev \
-        tzdata \
-        wget && \
-    apt-get clean && \
-    rm -rf /var/lib/apt/lists*
-
-COPY ci/scripts/install_minio.sh /arrow/ci/scripts/
-RUN /arrow/ci/scripts/install_minio.sh ${arch} linux latest /usr/local
-COPY ci/scripts/install_gcs_testbench.sh /arrow/ci/scripts/
-RUN /arrow/ci/scripts/install_gcs_testbench.sh ${arch} default
-
-# Prioritize system packages and local installation
-# The following dependencies will be downloaded due to missing/invalid packages
-# provided by the distribution:
-# - libc-ares-dev does not install CMake config files
-# - flatbuffer is not packaged
-# - libgtest-dev only provide sources
-# - libprotobuf-dev only provide sources
-ENV ARROW_BUILD_TESTS=ON \
-    ARROW_DEPENDENCY_SOURCE=SYSTEM \
-    ARROW_DATASET=ON \
-    ARROW_FLIGHT=OFF \
-    ARROW_GANDIVA=ON \
-    ARROW_HDFS=ON \
-    ARROW_HOME=/usr/local \
-    ARROW_INSTALL_NAME_RPATH=OFF \
-    ARROW_NO_DEPRECATED_API=ON \
-    ARROW_ORC=ON \
-    ARROW_PARQUET=ON \
-    ARROW_PLASMA=ON \
-    ARROW_S3=ON \
-    ARROW_USE_ASAN=OFF \
-    ARROW_USE_CCACHE=ON \
-    ARROW_USE_UBSAN=OFF \
-    ARROW_WITH_BROTLI=ON \
-    ARROW_WITH_BZ2=ON \
-    ARROW_WITH_LZ4=ON \
-    ARROW_WITH_SNAPPY=ON \
-    ARROW_WITH_ZLIB=ON \
-    ARROW_WITH_ZSTD=ON \
-    AWSSDK_SOURCE=BUNDLED \
-    GTest_SOURCE=BUNDLED \
-    ORC_SOURCE=BUNDLED \
-    PARQUET_BUILD_EXAMPLES=ON \
-    PARQUET_BUILD_EXECUTABLES=ON \
-    PATH=/usr/lib/ccache/:$PATH \
-    PYTHON=python3
diff --git a/ci/docker/ubuntu-21.04-cpp.dockerfile b/ci/docker/ubuntu-21.04-cpp.dockerfile
index 9fc857c6266..58639cb1cf9 100644
--- a/ci/docker/ubuntu-21.04-cpp.dockerfile
+++ b/ci/docker/ubuntu-21.04-cpp.dockerfile
@@ -15,9 +15,8 @@
 # specific language governing permissions and limitations
 # under the License.
 
-ARG base=amd64/ubuntu:20.04
+ARG base=amd64/ubuntu:21.04
 FROM ${base}
-ARG arch
 
 SHELL ["/bin/bash", "-o", "pipefail", "-c"]
 
@@ -30,20 +29,27 @@ RUN echo "debconf debconf/frontend select Noninteractive" | \
 # while debugging package list with docker build.
 ARG clang_tools
 ARG llvm
-RUN if [ "${llvm}" -gt "10" ]; then \
+RUN latest_system_llvm=12 && \
+    if [ ${llvm} -gt ${latest_system_llvm} -o \
+         ${clang_tools} -gt ${latest_system_llvm} ]; then \
       apt-get update -y -q && \
       apt-get install -y -q --no-install-recommends \
           apt-transport-https \
           ca-certificates \
           gnupg \
+          lsb-release \
           wget && \
       wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add - && \
-      echo "deb https://apt.llvm.org/hirsute/ llvm-toolchain-hirsute-${llvm} main" > \
-         /etc/apt/sources.list.d/llvm.list && \
-      if [ "${clang_tools}" != "${llvm}" -a "${clang_tools}" -gt 10 ]; then \
-        echo "deb https://apt.llvm.org/hirsute/ llvm-toolchain-hirsute-${clang_tools} main" > \
+      code_name=$(lsb_release --codename --short) && \
+      if [ ${llvm} -gt 10 ]; then \
+        echo "deb https://apt.llvm.org/${code_name}/ llvm-toolchain-${code_name}-${llvm} main" > \
+           /etc/apt/sources.list.d/llvm.list; \
+      fi && \
+      if [ ${clang_tools} -ne ${llvm} -a \
+           ${clang_tools} -gt ${latest_system_llvm} ]; then \
+        echo "deb https://apt.llvm.org/${code_name}/ llvm-toolchain-${code_name}-${clang_tools} main" > \
            /etc/apt/sources.list.d/clang-tools.list; \
-      fi \
+      fi; \
     fi && \
     apt-get update -y -q && \
     apt-get install -y -q --no-install-recommends \
@@ -90,15 +96,17 @@ RUN apt-get update -y -q && \
         protobuf-compiler-grpc \
         python3-pip \
         rapidjson-dev \
+        rsync \
         tzdata \
         wget && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists*
 
 COPY ci/scripts/install_minio.sh /arrow/ci/scripts/
-RUN /arrow/ci/scripts/install_minio.sh ${arch} linux latest /usr/local
+RUN /arrow/ci/scripts/install_minio.sh latest /usr/local
+
 COPY ci/scripts/install_gcs_testbench.sh /arrow/ci/scripts/
-RUN /arrow/ci/scripts/install_gcs_testbench.sh ${arch} default
+RUN /arrow/ci/scripts/install_gcs_testbench.sh default
 
 # Prioritize system packages and local installation
 # The following dependencies will be downloaded due to missing/invalid packages
diff --git a/ci/etc/rprofile b/ci/etc/rprofile
index 5ef1dca8ff3..e9e98b12e40 100644
--- a/ci/etc/rprofile
+++ b/ci/etc/rprofile
@@ -1,4 +1,4 @@
- local({
+local({
   .pick_cran <- function() {
     # Return a CRAN repo URL, preferring RSPM binaries if available for this OS
     rspm_template <- "https://packagemanager.rstudio.com/cran/__linux__/%s/latest"
@@ -38,14 +38,14 @@
       }
     }
 
-    return("https://cloud.r-project.org")
+    return(NULL)
   }
 
   options(
     Ncpus = parallel::detectCores(),
-    repos = tryCatch(.pick_cran(), error = function(e) "https://cloud.r-project.org"),
+    repos = c(tryCatch(.pick_cran(), error = function(e) NULL), "https://cloud.r-project.org"),
     HTTPUserAgent = sprintf(
-      'R/%s R (%s)',
+      "R/%s R (%s)",
       getRversion(),
       paste(getRversion(), R.version$platform, R.version$arch, R.version$os)
     )
diff --git a/ci/scripts/c_glib_build.sh b/ci/scripts/c_glib_build.sh
index ce3cea18e71..e0baf7f3d13 100755
--- a/ci/scripts/c_glib_build.sh
+++ b/ci/scripts/c_glib_build.sh
@@ -21,8 +21,11 @@ set -ex
 
 source_dir=${1}/c_glib
 build_dir=${2}/c_glib
-: ${ARROW_GLIB_GTK_DOC:=false}
+build_root=${2}
+
 : ${ARROW_GLIB_DEVELOPMENT_MODE:=false}
+: ${BUILD_DOCS_C_GLIB:=OFF}
+with_gtk_doc=$([ "${BUILD_DOCS_C_GLIB}" == "ON" ] && echo "true" || echo "false")
 
 export PKG_CONFIG_PATH=${ARROW_HOME}/lib/pkgconfig
 
@@ -35,7 +38,7 @@ mkdir -p ${build_dir}
 meson --prefix=$ARROW_HOME \
       --libdir=lib \
       -Ddevelopment_mode=${ARROW_GLIB_DEVELOPMENT_MODE} \
-      -Dgtk_doc=${ARROW_GLIB_GTK_DOC} \
+      -Dgtk_doc=${with_gtk_doc} \
       ${build_dir} \
       ${source_dir}
 
@@ -43,3 +46,8 @@ pushd ${build_dir}
 ninja
 ninja install
 popd
+
+if [ "${BUILD_DOCS_C_GLIB}" == "ON" ]; then
+  mkdir -p ${build_root}/docs/c_glib
+  rsync -a ${ARROW_HOME}/share/gtk-doc/html/ ${build_root}/docs/c_glib
+fi
diff --git a/ci/scripts/cpp_build.sh b/ci/scripts/cpp_build.sh
index 0ea9b1b89dc..f791ddd5645 100755
--- a/ci/scripts/cpp_build.sh
+++ b/ci/scripts/cpp_build.sh
@@ -21,9 +21,9 @@ set -ex
 
 source_dir=${1}/cpp
 build_dir=${2}/cpp
-with_docs=${3:-false}
 
 : ${ARROW_USE_CCACHE:=OFF}
+: ${BUILD_DOCS_CPP:=OFF}
 
 # TODO(kszucs): consider to move these to CMake
 if [ ! -z "${CONDA_PREFIX}" ]; then
@@ -49,97 +49,98 @@ fi
 mkdir -p ${build_dir}
 pushd ${build_dir}
 
-cmake -G "${CMAKE_GENERATOR:-Ninja}" \
-      -DARROW_BOOST_USE_SHARED=${ARROW_BOOST_USE_SHARED:-ON} \
-      -DARROW_BUILD_BENCHMARKS=${ARROW_BUILD_BENCHMARKS:-OFF} \
-      -DARROW_BUILD_BENCHMARKS_REFERENCE=${ARROW_BUILD_BENCHMARKS:-OFF} \
-      -DARROW_BUILD_EXAMPLES=${ARROW_BUILD_EXAMPLES:-OFF} \
-      -DARROW_BUILD_INTEGRATION=${ARROW_BUILD_INTEGRATION:-OFF} \
-      -DARROW_BUILD_SHARED=${ARROW_BUILD_SHARED:-ON} \
-      -DARROW_BUILD_STATIC=${ARROW_BUILD_STATIC:-ON} \
-      -DARROW_BUILD_TESTS=${ARROW_BUILD_TESTS:-OFF} \
-      -DARROW_BUILD_UTILITIES=${ARROW_BUILD_UTILITIES:-ON} \
-      -DARROW_COMPUTE=${ARROW_COMPUTE:-ON} \
-      -DARROW_CSV=${ARROW_CSV:-ON} \
-      -DARROW_CUDA=${ARROW_CUDA:-OFF} \
-      -DARROW_CXXFLAGS=${ARROW_CXXFLAGS:-} \
-      -DARROW_DATASET=${ARROW_DATASET:-ON} \
-      -DARROW_ENGINE=${ARROW_ENGINE:-ON} \
-      -DARROW_DEPENDENCY_SOURCE=${ARROW_DEPENDENCY_SOURCE:-AUTO} \
-      -DARROW_EXTRA_ERROR_CONTEXT=${ARROW_EXTRA_ERROR_CONTEXT:-OFF} \
-      -DARROW_ENABLE_TIMING_TESTS=${ARROW_ENABLE_TIMING_TESTS:-ON} \
-      -DARROW_FILESYSTEM=${ARROW_FILESYSTEM:-ON} \
-      -DARROW_FLIGHT=${ARROW_FLIGHT:-OFF} \
-      -DARROW_FUZZING=${ARROW_FUZZING:-OFF} \
-      -DARROW_GANDIVA_JAVA=${ARROW_GANDIVA_JAVA:-OFF} \
-      -DARROW_GANDIVA_PC_CXX_FLAGS=${ARROW_GANDIVA_PC_CXX_FLAGS:-} \
-      -DARROW_GANDIVA=${ARROW_GANDIVA:-OFF} \
-      -DARROW_GCS=${ARROW_GCS:-OFF} \
-      -DARROW_HDFS=${ARROW_HDFS:-ON} \
-      -DARROW_HIVESERVER2=${ARROW_HIVESERVER2:-OFF} \
-      -DARROW_INSTALL_NAME_RPATH=${ARROW_INSTALL_NAME_RPATH:-ON} \
-      -DARROW_JEMALLOC=${ARROW_JEMALLOC:-ON} \
-      -DARROW_JNI=${ARROW_JNI:-OFF} \
-      -DARROW_JSON=${ARROW_JSON:-ON} \
-      -DARROW_LARGE_MEMORY_TESTS=${ARROW_LARGE_MEMORY_TESTS:-OFF} \
-      -DARROW_MIMALLOC=${ARROW_MIMALLOC:-OFF} \
-      -DARROW_NO_DEPRECATED_API=${ARROW_NO_DEPRECATED_API:-OFF} \
-      -DARROW_ORC=${ARROW_ORC:-OFF} \
-      -DARROW_PARQUET=${ARROW_PARQUET:-OFF} \
-      -DARROW_PLASMA_JAVA_CLIENT=${ARROW_PLASMA_JAVA_CLIENT:-OFF} \
-      -DARROW_PLASMA=${ARROW_PLASMA:-OFF} \
-      -DARROW_PYTHON=${ARROW_PYTHON:-OFF} \
-      -DARROW_RUNTIME_SIMD_LEVEL=${ARROW_RUNTIME_SIMD_LEVEL:-MAX} \
-      -DARROW_S3=${ARROW_S3:-OFF} \
-      -DARROW_SKYHOOK=${ARROW_SKYHOOK:-OFF} \
-      -DARROW_TEST_LINKAGE=${ARROW_TEST_LINKAGE:-shared} \
-      -DARROW_TEST_MEMCHECK=${ARROW_TEST_MEMCHECK:-OFF} \
-      -DARROW_USE_ASAN=${ARROW_USE_ASAN:-OFF} \
-      -DARROW_USE_CCACHE=${ARROW_USE_CCACHE:-ON} \
-      -DARROW_USE_GLOG=${ARROW_USE_GLOG:-OFF} \
-      -DARROW_USE_LD_GOLD=${ARROW_USE_LD_GOLD:-OFF} \
-      -DARROW_USE_PRECOMPILED_HEADERS=${ARROW_USE_PRECOMPILED_HEADERS:-OFF} \
-      -DARROW_USE_STATIC_CRT=${ARROW_USE_STATIC_CRT:-OFF} \
-      -DARROW_USE_TSAN=${ARROW_USE_TSAN:-OFF} \
-      -DARROW_USE_UBSAN=${ARROW_USE_UBSAN:-OFF} \
-      -DARROW_VERBOSE_THIRDPARTY_BUILD=${ARROW_VERBOSE_THIRDPARTY_BUILD:-OFF} \
-      -DARROW_WITH_BROTLI=${ARROW_WITH_BROTLI:-OFF} \
-      -DARROW_WITH_BZ2=${ARROW_WITH_BZ2:-OFF} \
-      -DARROW_WITH_LZ4=${ARROW_WITH_LZ4:-OFF} \
-      -DARROW_WITH_SNAPPY=${ARROW_WITH_SNAPPY:-OFF} \
-      -DARROW_WITH_UTF8PROC=${ARROW_WITH_UTF8PROC:-ON} \
-      -DARROW_WITH_ZLIB=${ARROW_WITH_ZLIB:-OFF} \
-      -DARROW_WITH_ZSTD=${ARROW_WITH_ZSTD:-OFF} \
-      -DAWSSDK_SOURCE=${AWSSDK_SOURCE:-} \
-      -Dbenchmark_SOURCE=${benchmark_SOURCE:-} \
-      -DBOOST_SOURCE=${BOOST_SOURCE:-} \
-      -DBrotli_SOURCE=${Brotli_SOURCE:-} \
-      -DBUILD_WARNING_LEVEL=${BUILD_WARNING_LEVEL:-CHECKIN} \
-      -Dc-ares_SOURCE=${cares_SOURCE:-} \
-      -DCMAKE_BUILD_TYPE=${ARROW_BUILD_TYPE:-debug} \
-      -DCMAKE_C_FLAGS="${CFLAGS:-}" \
-      -DCMAKE_CXX_FLAGS="${CXXFLAGS:-}" \
-      -DCMAKE_INSTALL_LIBDIR=${CMAKE_INSTALL_LIBDIR:-lib} \
-      -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX:-${ARROW_HOME}} \
-      -DCMAKE_UNITY_BUILD=${CMAKE_UNITY_BUILD:-OFF} \
-      -Dgflags_SOURCE=${gflags_SOURCE:-} \
-      -Dgoogle_cloud_cpp_storage_SOURCE=${google_cloud_cpp_storage_SOURCE:-} \
-      -DgRPC_SOURCE=${gRPC_SOURCE:-} \
-      -DGTest_SOURCE=${GTest_SOURCE:-} \
-      -DLz4_SOURCE=${Lz4_SOURCE:-} \
-      -DORC_SOURCE=${ORC_SOURCE:-} \
-      -DPARQUET_BUILD_EXECUTABLES=${PARQUET_BUILD_EXECUTABLES:-OFF} \
-      -DPARQUET_BUILD_EXAMPLES=${PARQUET_BUILD_EXAMPLES:-OFF} \
-      -DPARQUET_REQUIRE_ENCRYPTION=${PARQUET_REQUIRE_ENCRYPTION:-ON} \
-      -DProtobuf_SOURCE=${Protobuf_SOURCE:-} \
-      -DRapidJSON_SOURCE=${RapidJSON_SOURCE:-} \
-      -Dre2_SOURCE=${re2_SOURCE:-} \
-      -DSnappy_SOURCE=${Snappy_SOURCE:-} \
-      -DThrift_SOURCE=${Thrift_SOURCE:-} \
-      -Dutf8proc_SOURCE=${utf8proc_SOURCE:-} \
-      -Dzstd_SOURCE=${zstd_SOURCE:-} \
-      ${CMAKE_ARGS} \
-      ${source_dir}
+cmake \
+  -DARROW_BOOST_USE_SHARED=${ARROW_BOOST_USE_SHARED:-ON} \
+  -DARROW_BUILD_BENCHMARKS_REFERENCE=${ARROW_BUILD_BENCHMARKS:-OFF} \
+  -DARROW_BUILD_BENCHMARKS=${ARROW_BUILD_BENCHMARKS:-OFF} \
+  -DARROW_BUILD_EXAMPLES=${ARROW_BUILD_EXAMPLES:-OFF} \
+  -DARROW_BUILD_INTEGRATION=${ARROW_BUILD_INTEGRATION:-OFF} \
+  -DARROW_BUILD_SHARED=${ARROW_BUILD_SHARED:-ON} \
+  -DARROW_BUILD_STATIC=${ARROW_BUILD_STATIC:-ON} \
+  -DARROW_BUILD_TESTS=${ARROW_BUILD_TESTS:-OFF} \
+  -DARROW_BUILD_UTILITIES=${ARROW_BUILD_UTILITIES:-ON} \
+  -DARROW_COMPUTE=${ARROW_COMPUTE:-ON} \
+  -DARROW_CSV=${ARROW_CSV:-ON} \
+  -DARROW_CUDA=${ARROW_CUDA:-OFF} \
+  -DARROW_CXXFLAGS=${ARROW_CXXFLAGS:-} \
+  -DARROW_DATASET=${ARROW_DATASET:-ON} \
+  -DARROW_DEPENDENCY_SOURCE=${ARROW_DEPENDENCY_SOURCE:-AUTO} \
+  -DARROW_ENABLE_TIMING_TESTS=${ARROW_ENABLE_TIMING_TESTS:-ON} \
+  -DARROW_ENGINE=${ARROW_ENGINE:-ON} \
+  -DARROW_EXTRA_ERROR_CONTEXT=${ARROW_EXTRA_ERROR_CONTEXT:-OFF} \
+  -DARROW_FILESYSTEM=${ARROW_FILESYSTEM:-ON} \
+  -DARROW_FLIGHT=${ARROW_FLIGHT:-OFF} \
+  -DARROW_FUZZING=${ARROW_FUZZING:-OFF} \
+  -DARROW_GANDIVA_JAVA=${ARROW_GANDIVA_JAVA:-OFF} \
+  -DARROW_GANDIVA_PC_CXX_FLAGS=${ARROW_GANDIVA_PC_CXX_FLAGS:-} \
+  -DARROW_GANDIVA=${ARROW_GANDIVA:-OFF} \
+  -DARROW_GCS=${ARROW_GCS:-OFF} \
+  -DARROW_HDFS=${ARROW_HDFS:-ON} \
+  -DARROW_HIVESERVER2=${ARROW_HIVESERVER2:-OFF} \
+  -DARROW_INSTALL_NAME_RPATH=${ARROW_INSTALL_NAME_RPATH:-ON} \
+  -DARROW_JEMALLOC=${ARROW_JEMALLOC:-ON} \
+  -DARROW_JNI=${ARROW_JNI:-OFF} \
+  -DARROW_JSON=${ARROW_JSON:-ON} \
+  -DARROW_LARGE_MEMORY_TESTS=${ARROW_LARGE_MEMORY_TESTS:-OFF} \
+  -DARROW_MIMALLOC=${ARROW_MIMALLOC:-OFF} \
+  -DARROW_NO_DEPRECATED_API=${ARROW_NO_DEPRECATED_API:-OFF} \
+  -DARROW_ORC=${ARROW_ORC:-OFF} \
+  -DARROW_PARQUET=${ARROW_PARQUET:-OFF} \
+  -DARROW_PLASMA_JAVA_CLIENT=${ARROW_PLASMA_JAVA_CLIENT:-OFF} \
+  -DARROW_PLASMA=${ARROW_PLASMA:-OFF} \
+  -DARROW_PYTHON=${ARROW_PYTHON:-OFF} \
+  -DARROW_RUNTIME_SIMD_LEVEL=${ARROW_RUNTIME_SIMD_LEVEL:-MAX} \
+  -DARROW_S3=${ARROW_S3:-OFF} \
+  -DARROW_SKYHOOK=${ARROW_SKYHOOK:-OFF} \
+  -DARROW_TEST_LINKAGE=${ARROW_TEST_LINKAGE:-shared} \
+  -DARROW_TEST_MEMCHECK=${ARROW_TEST_MEMCHECK:-OFF} \
+  -DARROW_USE_ASAN=${ARROW_USE_ASAN:-OFF} \
+  -DARROW_USE_CCACHE=${ARROW_USE_CCACHE:-ON} \
+  -DARROW_USE_GLOG=${ARROW_USE_GLOG:-OFF} \
+  -DARROW_USE_LD_GOLD=${ARROW_USE_LD_GOLD:-OFF} \
+  -DARROW_USE_PRECOMPILED_HEADERS=${ARROW_USE_PRECOMPILED_HEADERS:-OFF} \
+  -DARROW_USE_STATIC_CRT=${ARROW_USE_STATIC_CRT:-OFF} \
+  -DARROW_USE_TSAN=${ARROW_USE_TSAN:-OFF} \
+  -DARROW_USE_UBSAN=${ARROW_USE_UBSAN:-OFF} \
+  -DARROW_VERBOSE_THIRDPARTY_BUILD=${ARROW_VERBOSE_THIRDPARTY_BUILD:-OFF} \
+  -DARROW_WITH_BROTLI=${ARROW_WITH_BROTLI:-OFF} \
+  -DARROW_WITH_BZ2=${ARROW_WITH_BZ2:-OFF} \
+  -DARROW_WITH_LZ4=${ARROW_WITH_LZ4:-OFF} \
+  -DARROW_WITH_SNAPPY=${ARROW_WITH_SNAPPY:-OFF} \
+  -DARROW_WITH_UTF8PROC=${ARROW_WITH_UTF8PROC:-ON} \
+  -DARROW_WITH_ZLIB=${ARROW_WITH_ZLIB:-OFF} \
+  -DARROW_WITH_ZSTD=${ARROW_WITH_ZSTD:-OFF} \
+  -DAWSSDK_SOURCE=${AWSSDK_SOURCE:-} \
+  -Dbenchmark_SOURCE=${benchmark_SOURCE:-} \
+  -DBOOST_SOURCE=${BOOST_SOURCE:-} \
+  -DBrotli_SOURCE=${Brotli_SOURCE:-} \
+  -DBUILD_WARNING_LEVEL=${BUILD_WARNING_LEVEL:-CHECKIN} \
+  -Dc-ares_SOURCE=${cares_SOURCE:-} \
+  -DCMAKE_BUILD_TYPE=${ARROW_BUILD_TYPE:-debug} \
+  -DCMAKE_C_FLAGS="${CFLAGS:-}" \
+  -DCMAKE_CXX_FLAGS="${CXXFLAGS:-}" \
+  -DCMAKE_INSTALL_LIBDIR=${CMAKE_INSTALL_LIBDIR:-lib} \
+  -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX:-${ARROW_HOME}} \
+  -DCMAKE_UNITY_BUILD=${CMAKE_UNITY_BUILD:-OFF} \
+  -Dgflags_SOURCE=${gflags_SOURCE:-} \
+  -Dgoogle_cloud_cpp_storage_SOURCE=${google_cloud_cpp_storage_SOURCE:-} \
+  -DgRPC_SOURCE=${gRPC_SOURCE:-} \
+  -DGTest_SOURCE=${GTest_SOURCE:-} \
+  -DLz4_SOURCE=${Lz4_SOURCE:-} \
+  -DORC_SOURCE=${ORC_SOURCE:-} \
+  -DPARQUET_BUILD_EXAMPLES=${PARQUET_BUILD_EXAMPLES:-OFF} \
+  -DPARQUET_BUILD_EXECUTABLES=${PARQUET_BUILD_EXECUTABLES:-OFF} \
+  -DPARQUET_REQUIRE_ENCRYPTION=${PARQUET_REQUIRE_ENCRYPTION:-ON} \
+  -DProtobuf_SOURCE=${Protobuf_SOURCE:-} \
+  -DRapidJSON_SOURCE=${RapidJSON_SOURCE:-} \
+  -Dre2_SOURCE=${re2_SOURCE:-} \
+  -DSnappy_SOURCE=${Snappy_SOURCE:-} \
+  -DThrift_SOURCE=${Thrift_SOURCE:-} \
+  -Dutf8proc_SOURCE=${utf8proc_SOURCE:-} \
+  -Dzstd_SOURCE=${zstd_SOURCE:-} \
+  -G "${CMAKE_GENERATOR:-Ninja}" \
+  ${CMAKE_ARGS} \
+  ${source_dir}
 
 if [ ! -z "${CPP_MAKE_PARALLELISM}" ]; then
   time cmake --build . --target install -- -j${CPP_MAKE_PARALLELISM}
@@ -158,7 +159,7 @@ if [ "${ARROW_USE_CCACHE}" == "ON" ]; then
     ccache -s
 fi
 
-if [ "${with_docs}" == "true" ]; then
+if [ "${DOCS_BUILD_CPP}" == "ON" ]; then
   pushd ${source_dir}/apidoc
   doxygen
   popd
diff --git a/ci/scripts/docs_build.sh b/ci/scripts/docs_build.sh
deleted file mode 100755
index e6ee768ee87..00000000000
--- a/ci/scripts/docs_build.sh
+++ /dev/null
@@ -1,48 +0,0 @@
-#!/usr/bin/env bash
-#
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-set -ex
-
-arrow_dir=${1}
-build_dir=${2}/docs
-
-export LD_LIBRARY_PATH=${ARROW_HOME}/lib:${LD_LIBRARY_PATH}
-export PKG_CONFIG_PATH=${ARROW_HOME}/lib/pkgconfig:${PKG_CONFIG_PATH}
-export GI_TYPELIB_PATH=${ARROW_HOME}/lib/girepository-1.0
-export CFLAGS="-DARROW_NO_DEPRECATED_API"
-export CXXFLAGS="-DARROW_NO_DEPRECATED_API"
-
-ncpus=$(python3 -c "import os; print(os.cpu_count())")
-
-# Sphinx docs
-sphinx-build -b html -j ${ncpus} ${arrow_dir}/docs/source ${build_dir}
-
-# C++ - original doxygen
-# rsync -a ${arrow_dir}/cpp/apidoc/ ${build_dir}/cpp
-
-# R
-rsync -a ${arrow_dir}/r/docs/ ${build_dir}/r
-
-# C GLib
-rsync -a ${ARROW_HOME}/share/gtk-doc/html/ ${build_dir}/c_glib
-
-# Java
-rsync -a ${arrow_dir}/java/target/site/apidocs/ ${build_dir}/java/reference
-
-# Javascript
-rsync -a ${arrow_dir}/js/doc/ ${build_dir}/js
diff --git a/ci/scripts/install_ccache.sh b/ci/scripts/install_ccache.sh
new file mode 100755
index 00000000000..8c64fe56c41
--- /dev/null
+++ b/ci/scripts/install_ccache.sh
@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+set -e
+
+if [ "$#" -ne 2 ]; then
+  echo "Usage: $0 <version> <prefix>"
+  exit 1
+fi
+
+version=$1
+prefix=$2
+url="https://github.com/ccache/ccache/archive/v${version}.tar.gz"
+
+mkdir /tmp/ccache
+wget -q ${url} -O - | tar -xzf - --directory /tmp/ccache --strip-components=1
+
+mkdir /tmp/ccache/build
+pushd /tmp/ccache/build
+cmake \
+  -GNinja \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_INSTALL_PREFIX=${prefix} \
+  -DZSTD_FROM_INTERNET=ON \
+  ..
+ninja install
+popd
+
+rm -rf /tmp/ccache
diff --git a/ci/scripts/install_cmake.sh b/ci/scripts/install_cmake.sh
new file mode 100755
index 00000000000..2f5e5d52051
--- /dev/null
+++ b/ci/scripts/install_cmake.sh
@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+set -e
+
+declare -A archs
+archs=([amd64]=x86_64
+       [arm64v8]=aarch64)
+
+declare -A platforms
+platforms=([linux]=linux
+           [macos]=macos
+           [windows]=windows)
+
+if [ "$#" -ne 4 ]; then
+  echo "Usage: $0 <architecture> <platform> <version> <prefix>"
+  exit 1
+fi
+
+arch=${archs[$1]}
+platform=${platforms[$2]}
+version=$3
+prefix=$4
+
+url="https://github.com/Kitware/CMake/releases/download/v${version}/cmake-${version}-${platform}-${arch}.tar.gz"
+wget -q ${url} -O - | tar -xzf - --directory ${prefix} --strip-components=1
diff --git a/ci/scripts/install_conda.sh b/ci/scripts/install_conda.sh
index f4d313b63df..2e864163022 100755
--- a/ci/scripts/install_conda.sh
+++ b/ci/scripts/install_conda.sh
@@ -19,48 +19,30 @@
 
 set -e
 
-declare -A archs
-archs=([amd64]=x86_64
-       [arm32v7]=armv7l
-       [ppc64le]=ppc64le
-       [i386]=x86)
-
-declare -A platforms
-platforms=([windows]=Windows
-           [macos]=MacOSX
-           [linux]=Linux)
-
-if [ "$#" -ne 4 ]; then
-  echo "Usage: $0 <architecture> <platform> <version> <prefix>"
-  exit 1
-elif [[ -z ${archs[$1]} ]]; then
-  echo "Unexpected architecture: ${1}"
-  exit 1
-elif [[ -z ${platforms[$2]} ]]; then
-  echo "Unexpected platform: ${2}"
+if [ "$#" -ne 3 ]; then
+  echo "Usage: $0 <installer: miniforge or mambaforge> <version> <prefix>"
   exit 1
 fi
 
-arch=${archs[$1]}
-platform=${platforms[$2]}
-version=$3
-prefix=$4
+arch=$(uname -m)
+platform=$(uname)
+installer=$1
+version=$2
+prefix=$3
 
 echo "Downloading Miniconda installer..."
-wget -nv https://repo.continuum.io/miniconda/Miniconda3-${version}-${platform}-${arch}.sh -O /tmp/miniconda.sh
-bash /tmp/miniconda.sh -b -p ${prefix}
-rm /tmp/miniconda.sh
+wget -nv https://github.com/conda-forge/miniforge/releases/latest/download/${installer^}-${platform}-${arch}.sh -O /tmp/installer.sh
+bash /tmp/installer.sh -b -p ${prefix}
+rm /tmp/installer.sh
 
 # Like "conda init", but for POSIX sh rather than bash
 ln -s ${prefix}/etc/profile.d/conda.sh /etc/profile.d/conda.sh
 
+export PATH=/opt/conda/bin:$PATH
+
 # Configure
-source /etc/profile.d/conda.sh
-conda config --add channels conda-forge
-conda config --set channel_priority strict
 conda config --set show_channel_urls True
 conda config --set remote_connect_timeout_secs 12
 
 # Update and clean
-conda update --all -y
 conda clean --all -y
diff --git a/ci/scripts/install_dask.sh b/ci/scripts/install_dask.sh
index 954ce3249d9..ff0def006a8 100755
--- a/ci/scripts/install_dask.sh
+++ b/ci/scripts/install_dask.sh
@@ -29,8 +29,7 @@ dask=$1
 if [ "${dask}" = "master" ]; then
   pip install https://github.com/dask/dask/archive/main.tar.gz#egg=dask[dataframe]
 elif [ "${dask}" = "latest" ]; then
-  conda install -q dask
+  pip install dask
 else
-  conda install -q dask=${dask}
+  pip install dask==${dask}
 fi
-conda clean --all
diff --git a/ci/scripts/install_gcs_testbench.sh b/ci/scripts/install_gcs_testbench.sh
index 579a78944b5..16e3c4042cf 100755
--- a/ci/scripts/install_gcs_testbench.sh
+++ b/ci/scripts/install_gcs_testbench.sh
@@ -19,18 +19,17 @@
 
 set -e
 
-if [ "$#" -ne 2 ]; then
-  echo "Usage: $0 <arch> <storage-testbench version>"
+if [ "$#" -ne 1 ]; then
+  echo "Usage: $0 <storage-testbench version>"
   exit 1
 fi
 
-arch=$1
-if [ "${arch}" != "amd64" ]; then
+if [ "$(uname -m)" != "x86_64" ]; then
   echo "GCS testbench won't install on non-x86 architecture"
   exit 0
 fi
 
-version=$2
+version=$1
 if [[ "${version}" -eq "default" ]]; then
   version="v0.7.0"
 fi
diff --git a/ci/scripts/install_glibc.sh b/ci/scripts/install_glibc.sh
new file mode 100755
index 00000000000..d1a49818178
--- /dev/null
+++ b/ci/scripts/install_glibc.sh
@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+set -e
+
+if [ "$#" -ne 2 ]; then
+  echo "Usage: $0 <version> <prefix>"
+  exit 1
+fi
+
+version=$1
+prefix=$2
+
+url="http://ftp.gnu.org/gnu/glibc/glibc-${version}.tar.gz"
+
+mkdir /tmp/glibc
+wget -q ${url} -O - | tar -xzf - --directory /tmp/glibc --strip-components=1
+
+mkdir /tmp/glibc/build
+pushd /tmp/glibc/build
+../configure --prefix=${prefix}
+make -j$(nproc)
+make install
+popd
+
+rm -rf /tmp/glibc
diff --git a/ci/scripts/install_minio.sh b/ci/scripts/install_minio.sh
index 5cda46e59e6..af99f966661 100755
--- a/ci/scripts/install_minio.sh
+++ b/ci/scripts/install_minio.sh
@@ -20,34 +20,37 @@
 set -e
 
 declare -A archs
-archs=([amd64]=amd64
-       [arm64v8]=arm64
-       [arm32v7]=arm
+archs=([x86_64]=amd64
+       [arm64]=arm64
+       [aarch64]=arm64
        [s390x]=s390x)
 
 declare -A platforms
-platforms=([linux]=linux
-           [macos]=darwin)
+platforms=([Linux]=linux
+           [Darwin]=darwin)
 
-arch=${archs[$1]}
-platform=${platforms[$2]}
-version=$3
-prefix=$4
+arch=$(uname -m)
+platform=$(uname)
+version=$1
+prefix=$2
 
-if [ "$#" -ne 4 ]; then
-  echo "Usage: $0 <architecture> <platform> <version> <prefix>"
+if [ "$#" -ne 2 ]; then
+  echo "Usage: $0 <version> <prefix>"
   exit 1
-elif [[ -z ${arch} ]]; then
-  echo "Unexpected architecture: ${1}"
-  exit 1
-elif [[ -z ${platform} ]]; then
-  echo "Unexpected platform: ${2}"
-  exit 1
-elif [[ ${version} != "latest" ]]; then
+elif [ -z ${archs[$arch]} ]; then
+  echo "Unsupported architecture: ${arch}"
+  exit 0
+elif [ -z ${platforms[$platform]} ]; then
+  echo "Unsupported platform: ${platform}"
+  exit 0
+elif [ "${version}" != "latest" ]; then
   echo "Cannot fetch specific versions of minio, only latest is supported."
   exit 1
 fi
 
+arch=${archs[$arch]}
+platform=${platforms[$platform]}
+
 if [[ ! -x ${prefix}/bin/minio ]]; then
   url="https://dl.min.io/server/minio/release/${platform}-${arch}/minio"
   echo "Fetching ${url}..."
diff --git a/ci/scripts/install_ninja.sh b/ci/scripts/install_ninja.sh
new file mode 100755
index 00000000000..0440d563fb1
--- /dev/null
+++ b/ci/scripts/install_ninja.sh
@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+set -e
+
+if [ "$#" -ne 2 ]; then
+  echo "Usage: $0 <version> <prefix>"
+  exit 1
+fi
+
+version=$1
+prefix=$2
+
+url="https://github.com/ninja-build/ninja/archive/v${version}.tar.gz"
+
+mkdir /tmp/ninja
+wget -q ${url} -O - | tar -xzf - --directory /tmp/ninja --strip-components=1
+
+pushd /tmp/ninja
+./configure.py --bootstrap
+mv ninja ${prefix}/bin
+popd
+
+rm -rf /tmp/ninja
diff --git a/ci/scripts/install_vcpkg.sh b/ci/scripts/install_vcpkg.sh
index fe99a7fea2f..cc80582326e 100755
--- a/ci/scripts/install_vcpkg.sh
+++ b/ci/scripts/install_vcpkg.sh
@@ -19,21 +19,35 @@
 
 set -e
 
-if [ "$#" -ne 2 ]; then
-  echo "Usage: $0 <vcpkg version> <target directory>"
+if [ "$#" -lt 1 ]; then
+  echo "Usage: $0 ``<target-directory> [<vcpkg-version> [<vcpkg-ports-patch>]]"
   exit 1
 fi
 
-vcpkg_version=$1
-vcpkg_destination=$2
-vcpkg_patch=$(realpath $(dirname "${0}")/../vcpkg/ports.patch)
+arrow_dir=$(cd -- "$(dirname -- "$0")/../.." && pwd -P)
+default_vcpkg_version=$(cat "${arrow_dir}/.env" | grep "VCPKG" | cut -d "=" -f2 | tr -d '"')
+default_vcpkg_ports_patch="${arrow_dir}/ci/vcpkg/ports.patch"
 
-git clone --depth 1 --branch ${vcpkg_version} https://github.com/microsoft/vcpkg ${vcpkg_destination}
+vcpkg_destination=$1
+vcpkg_version=${2:-$default_vcpkg_version}
+vcpkg_ports_patch=${3:-$default_vcpkg_ports_patch}
+
+# reduce the fetched data using a shallow clone
+git clone --shallow-since=2021-04-01 https://github.com/microsoft/vcpkg ${vcpkg_destination}
 
 pushd ${vcpkg_destination}
 
-./bootstrap-vcpkg.sh -useSystemBinaries -disableMetrics
-git apply --ignore-whitespace ${vcpkg_patch}
-echo "Patch successfully applied!"
+git checkout "${vcpkg_version}"
+
+if [[ "$OSTYPE" == "msys" ]]; then
+  ./bootstrap-vcpkg.bat -disableMetrics
+else
+  ./bootstrap-vcpkg.sh -disableMetrics
+fi
+
+if [ -f "${vcpkg_ports_patch}" ]; then
+  git apply --verbose --ignore-whitespace ${vcpkg_ports_patch}
+  echo "Patch successfully applied to the VCPKG port files!"
+fi
 
 popd
diff --git a/ci/scripts/java_build.sh b/ci/scripts/java_build.sh
index 1ba37606d3c..7693bd883a1 100755
--- a/ci/scripts/java_build.sh
+++ b/ci/scripts/java_build.sh
@@ -20,9 +20,11 @@ set -ex
 
 arrow_dir=${1}
 source_dir=${1}/java
-cpp_build_dir=${2}/cpp/${ARROW_BUILD_TYPE:-debug}
-cdata_dist_dir=${2}/java/c
-with_docs=${3:-false}
+build_dir=${2}
+cpp_build_dir=${build_dir}/cpp/${ARROW_BUILD_TYPE:-debug}
+cdata_dist_dir=${build_dir}/java/c
+
+: ${BUILD_DOCS_JAVA:=OFF}
 
 if [[ "$(uname -s)" == "Linux" ]] && [[ "$(uname -m)" == "s390x" ]]; then
   # Since some files for s390_64 are not available at maven central,
@@ -99,9 +101,11 @@ if [ "${ARROW_PLASMA}" = "ON" ]; then
   popd
 fi
 
-if [ "${with_docs}" == "true" ]; then
+if [ "${BUILD_DOCS_JAVA}" == "ON" ]; then
   # HTTP pooling is turned of to avoid download issues https://issues.apache.org/jira/browse/ARROW-11633
+  mkdir -p ${build_dir}/docs/java/reference
   ${mvn} -Dcheckstyle.skip=true -Dhttp.keepAlive=false -Dmaven.wagon.http.pool=false install site
+  rsync -a ${arrow_dir}/java/target/site/apidocs/ ${build_dir}/docs/java/reference
 fi
 
 popd
diff --git a/ci/scripts/js_build.sh b/ci/scripts/js_build.sh
index 12f58d54bb8..333c9cf441e 100755
--- a/ci/scripts/js_build.sh
+++ b/ci/scripts/js_build.sh
@@ -19,17 +19,19 @@
 
 set -ex
 
-source_dir=${1}/js
-with_docs=${2:-false}
+arrow_dir=${1}
+source_dir=${arrow_dir}/js
+build_dir=${2}
+
+: ${BUILD_DOCS_JS:=OFF}
 
 pushd ${source_dir}
 
 yarn --frozen-lockfile
-# TODO(kszucs): linting should be moved to archery
 yarn lint:ci
 yarn build
 
-if [ "${with_docs}" == "true" ]; then
+if [ "${BUILD_DOCS_JS}" == "ON" ]; then
   if [ "$(git config --get remote.origin.url)" == "https://github.com/apache/arrow.git" ]; then
     yarn doc
   elif [ "$(git config --get remote.upstream.url)" == "https://github.com/apache/arrow.git" ]; then
@@ -40,6 +42,8 @@ if [ "${with_docs}" == "true" ]; then
     echo "Failed to build docs because the remote is not set correctly. Please set the origin or upstream remote to https://github.com/apache/arrow.git or the apache remote to git@github.com:apache/arrow.git."
     exit 0
   fi
+  mkdir -p ${build_dir}/docs/js
+  rsync -a ${arrow_dir}/js/doc/ ${build_dir}/docs/js
 fi
 
 popd
diff --git a/ci/scripts/python_build.sh b/ci/scripts/python_build.sh
index ec6d723b2a7..ccf068078d5 100755
--- a/ci/scripts/python_build.sh
+++ b/ci/scripts/python_build.sh
@@ -19,9 +19,12 @@
 
 set -ex
 
-source_dir=${1}/python
+arrow_dir=${1}
+source_dir=${arrow_dir}/python
 build_dir=${2}/python
 
+: ${BUILD_DOCS_PYTHON:=OFF}
+
 if [ ! -z "${CONDA_PREFIX}" ]; then
   echo -e "===\n=== Conda environment for build\n==="
   conda list
@@ -52,3 +55,8 @@ ${PYTHON:-python} \
                    --record $relative_build_dir/record.txt
 
 popd
+
+if [ "${BUILD_DOCS_PYTHON}" == "ON" ]; then
+  ncpus=$(python -c "import os; print(os.cpu_count())")
+  sphinx-build -b html -j ${ncpus} ${arrow_dir}/docs/source ${build_dir}/docs
+fi
diff --git a/ci/scripts/python_wheel_macos_build.sh b/ci/scripts/python_wheel_macos_build.sh
index 1a52a2ad52b..4689a251aa0 100755
--- a/ci/scripts/python_wheel_macos_build.sh
+++ b/ci/scripts/python_wheel_macos_build.sh
@@ -64,6 +64,7 @@ echo "=== (${PYTHON_VERSION}) Building Arrow C++ libraries ==="
 : ${ARROW_DATASET:=ON}
 : ${ARROW_FLIGHT:=ON}
 : ${ARROW_GANDIVA:=OFF}
+: ${ARROW_GCS:=OFF}
 : ${ARROW_HDFS:=ON}
 : ${ARROW_JEMALLOC:=ON}
 : ${ARROW_MIMALLOC:=ON}
@@ -99,6 +100,7 @@ cmake \
     -DARROW_DEPENDENCY_USE_SHARED=OFF \
     -DARROW_FLIGHT=${ARROW_FLIGHT} \
     -DARROW_GANDIVA=${ARROW_GANDIVA} \
+    -DARROW_GCS=${ARROW_GCS} \
     -DARROW_HDFS=${ARROW_HDFS} \
     -DARROW_JEMALLOC=${ARROW_JEMALLOC} \
     -DARROW_MIMALLOC=${ARROW_MIMALLOC} \
diff --git a/ci/scripts/python_wheel_manylinux_build.sh b/ci/scripts/python_wheel_manylinux_build.sh
index 434605cf202..6b467ffc046 100755
--- a/ci/scripts/python_wheel_manylinux_build.sh
+++ b/ci/scripts/python_wheel_manylinux_build.sh
@@ -51,6 +51,7 @@ echo "=== (${PYTHON_VERSION}) Building Arrow C++ libraries ==="
 : ${ARROW_DATASET:=ON}
 : ${ARROW_FLIGHT:=ON}
 : ${ARROW_GANDIVA:=OFF}
+: ${ARROW_GCS:=OFF}
 : ${ARROW_HDFS:=ON}
 : ${ARROW_JEMALLOC:=ON}
 : ${ARROW_MIMALLOC:=ON}
@@ -88,8 +89,9 @@ cmake \
     -DARROW_DATASET=${ARROW_DATASET} \
     -DARROW_DEPENDENCY_SOURCE="VCPKG" \
     -DARROW_DEPENDENCY_USE_SHARED=OFF \
-    -DARROW_FLIGHT==${ARROW_FLIGHT} \
+    -DARROW_FLIGHT=${ARROW_FLIGHT} \
     -DARROW_GANDIVA=${ARROW_GANDIVA} \
+    -DARROW_GCS=${ARROW_GCS} \
     -DARROW_HDFS=${ARROW_HDFS} \
     -DARROW_JEMALLOC=${ARROW_JEMALLOC} \
     -DARROW_MIMALLOC=${ARROW_MIMALLOC} \
diff --git a/ci/scripts/r_build.sh b/ci/scripts/r_build.sh
index 2a2b9d7d161..a435b04317d 100755
--- a/ci/scripts/r_build.sh
+++ b/ci/scripts/r_build.sh
@@ -20,14 +20,17 @@ set -ex
 
 : ${R_BIN:=R}
 source_dir=${1}/r
-with_docs=${2:-false}
+build_dir=${2}
+
+: ${BUILD_DOCS_R:=OFF}
 
 pushd ${source_dir}
 
 ${R_BIN} CMD INSTALL ${INSTALL_ARGS} .
 
-if [ "${with_docs}" == "true" ]; then
+if [ "${BUILD_DOCS_R}" == "ON" ]; then
   ${R_BIN} -e "pkgdown::build_site(install = FALSE)"
+  rsync -a ${source_dir}/docs/ ${build_dir}/docs/r
 fi
 
-popd
\ No newline at end of file
+popd
diff --git a/ci/scripts/r_deps.sh b/ci/scripts/r_deps.sh
index 79977fca16d..0fa4368cd8a 100755
--- a/ci/scripts/r_deps.sh
+++ b/ci/scripts/r_deps.sh
@@ -41,6 +41,15 @@ fi
 # but we want to error/fail the build.
 # options(warn=2) turns warnings into errors
 ${R_BIN} -e "options(warn=2); install.packages('remotes'); remotes::install_cran(c('glue', 'rcmdcheck', 'sys')); remotes::install_deps(INSTALL_opts = '"${INSTALL_ARGS}"')"
+
+# (Temporarily) install DuckDB from source to avoid their Unity builds
+# (though only if we haven't filtered it out of the deps above,
+# and if we can't get a binary from RSPM)
+# Remove when there is a DuckDB release > 0.3.1-1
+if grep -q "duckdb" DESCRIPTION; then
+  ${R_BIN} -e "if (all(!grepl('packagemanager.rstudio', options('repos')))) { remotes::install_github('duckdb/duckdb', subdir = '/tools/rpkg', build = FALSE) }"
+fi
+
 # Separately install the optional/test dependencies but don't error on them,
 # they're not available everywhere and that's ok
 ${R_BIN} -e "remotes::install_deps(dependencies = TRUE, INSTALL_opts = '"${INSTALL_ARGS}"')"
diff --git a/ci/scripts/r_docker_configure.sh b/ci/scripts/r_docker_configure.sh
index 20c987085ae..4d837d9d7f1 100755
--- a/ci/scripts/r_docker_configure.sh
+++ b/ci/scripts/r_docker_configure.sh
@@ -69,11 +69,11 @@ if [ "$ARROW_S3" == "ON" ] || [ "$ARROW_R_DEV" == "TRUE" ]; then
 
   # The Dockerfile should have put this file here
   if [ -f "/arrow/ci/scripts/install_minio.sh" ] && [ "`which wget`" ]; then
-    /arrow/ci/scripts/install_minio.sh amd64 linux latest /usr/local
+    /arrow/ci/scripts/install_minio.sh latest /usr/local
   fi
 
   if [ -f "/arrow/ci/scripts/install_gcs_testbench.sh" ] && [ "`which pip`" ]; then
-    /arrow/ci/scripts/install_gcs_testbench.sh amd64 default
+    /arrow/ci/scripts/install_gcs_testbench.sh default
   fi
 fi
 
diff --git a/ci/vcpkg/x64-linux-static-debug.cmake b/ci/vcpkg/amd64-linux-static-debug.cmake
similarity index 100%
rename from ci/vcpkg/x64-linux-static-debug.cmake
rename to ci/vcpkg/amd64-linux-static-debug.cmake
diff --git a/ci/vcpkg/x64-linux-static-release.cmake b/ci/vcpkg/amd64-linux-static-release.cmake
similarity index 100%
rename from ci/vcpkg/x64-linux-static-release.cmake
rename to ci/vcpkg/amd64-linux-static-release.cmake
diff --git a/ci/vcpkg/x64-osx-static-debug.cmake b/ci/vcpkg/amd64-osx-static-debug.cmake
similarity index 100%
rename from ci/vcpkg/x64-osx-static-debug.cmake
rename to ci/vcpkg/amd64-osx-static-debug.cmake
diff --git a/ci/vcpkg/x64-osx-static-release.cmake b/ci/vcpkg/amd64-osx-static-release.cmake
similarity index 100%
rename from ci/vcpkg/x64-osx-static-release.cmake
rename to ci/vcpkg/amd64-osx-static-release.cmake
diff --git a/ci/vcpkg/x64-windows-static-md-debug.cmake b/ci/vcpkg/amd64-windows-static-md-debug.cmake
similarity index 100%
rename from ci/vcpkg/x64-windows-static-md-debug.cmake
rename to ci/vcpkg/amd64-windows-static-md-debug.cmake
diff --git a/ci/vcpkg/x64-windows-static-md-release.cmake b/ci/vcpkg/amd64-windows-static-md-release.cmake
similarity index 100%
rename from ci/vcpkg/x64-windows-static-md-release.cmake
rename to ci/vcpkg/amd64-windows-static-md-release.cmake
diff --git a/ci/vcpkg/ports.patch b/ci/vcpkg/ports.patch
index 7bcba49c194..940722abb2e 100644
--- a/ci/vcpkg/ports.patch
+++ b/ci/vcpkg/ports.patch
@@ -1,63 +1,245 @@
-diff --git a/ports/aws-c-common/portfile.cmake b/ports/aws-c-common/portfile.cmake
-index f3704ef05b..3af543058d 100644
---- a/ports/aws-c-common/portfile.cmake
-+++ b/ports/aws-c-common/portfile.cmake
-@@ -1,8 +1,8 @@
- vcpkg_from_github(
-     OUT_SOURCE_PATH SOURCE_PATH
-     REPO awslabs/aws-c-common
--    REF 4a21a1c0757083a16497fea27886f5f20ccdf334 # v0.4.56
--    SHA512 68898a8ac15d5490f45676eabfbe0df9e45370a74c543a28909fd0d85fed48dfcf4bcd6ea2d01d1a036dd352e2e4e0b08c48c63ab2a2b477fe150b46a827136e
-+    REF 13adef72b7813ec878817c6d50a7a3f241015d8a # v0.4.57
-+    SHA512 28256522ac6af544d7464e3e7dcd4dc802ae2b09728bf8f167f86a6487bb756d0cad5eb4a2480610b2967b9c24c4a7f70621894517aa2828ffdeb0479453803b
-     HEAD_REF master
-     PATCHES
-         disable-error-4068.patch # This patch fixes dependency port compilation failure
+diff --git a/ports/aws-c-auth/vcpkg.json b/ports/aws-c-auth/vcpkg.json
+index dc8f75e8..be703324 100644
+--- a/ports/aws-c-auth/vcpkg.json
++++ b/ports/aws-c-auth/vcpkg.json
+@@ -4,7 +4,7 @@
+   "port-version": 1,
+   "description": "C99 library implementation of AWS client-side authentication: standard credentials providers and signing.",
+   "homepage": "https://github.com/awslabs/aws-c-auth",
+-  "supports": "!arm & !uwp",
++  "supports": "!uwp",
+   "dependencies": [
+     "aws-c-common",
+     "aws-c-http",
+diff --git a/ports/aws-c-cal/vcpkg.json b/ports/aws-c-cal/vcpkg.json
+index 48c7406c..40e284dd 100644
+--- a/ports/aws-c-cal/vcpkg.json
++++ b/ports/aws-c-cal/vcpkg.json
+@@ -4,7 +4,7 @@
+   "port-version": 1,
+   "description": "C99 wrapper for cryptography primitives.",
+   "homepage": "https://github.com/awslabs/aws-c-cal",
+-  "supports": "!arm & !uwp",
++  "supports": "!uwp",
+   "dependencies": [
+     "aws-c-common",
+     {
+diff --git a/ports/aws-c-common/vcpkg.json b/ports/aws-c-common/vcpkg.json
+index 67d58320..3c8e96f7 100644
+--- a/ports/aws-c-common/vcpkg.json
++++ b/ports/aws-c-common/vcpkg.json
+@@ -4,7 +4,7 @@
+   "port-version": 1,
+   "description": "AWS common library for C",
+   "homepage": "https://github.com/awslabs/aws-c-common",
+-  "supports": "!arm & !uwp",
++  "supports": "!uwp",
+   "dependencies": [
+     "openssl",
+     {
+diff --git a/ports/aws-c-compression/vcpkg.json b/ports/aws-c-compression/vcpkg.json
+index 8b62d038..7aa75eda 100644
+--- a/ports/aws-c-compression/vcpkg.json
++++ b/ports/aws-c-compression/vcpkg.json
+@@ -4,7 +4,7 @@
+   "port-version": 1,
+   "description": "C99 implementation of huffman encoding/decoding",
+   "homepage": "https://github.com/awslabs/aws-c-compression",
+-  "supports": "!arm & !uwp",
++  "supports": "!uwp",
+   "dependencies": [
+     "aws-c-common",
+     {
+diff --git a/ports/aws-c-event-stream/vcpkg.json b/ports/aws-c-event-stream/vcpkg.json
+index 7018ea0b..df3f85af 100644
+--- a/ports/aws-c-event-stream/vcpkg.json
++++ b/ports/aws-c-event-stream/vcpkg.json
+@@ -4,7 +4,7 @@
+   "port-version": 1,
+   "description": "C99 implementation of the vnd.amazon.event-stream content-type.",
+   "homepage": "https://github.com/awslabs/aws-c-event-stream",
+-  "supports": "!arm & !uwp",
++  "supports": "!uwp",
+   "dependencies": [
+     "aws-c-cal",
+     "aws-c-common",
+diff --git a/ports/aws-c-http/vcpkg.json b/ports/aws-c-http/vcpkg.json
+index f7cf6547..20ee8be7 100644
+--- a/ports/aws-c-http/vcpkg.json
++++ b/ports/aws-c-http/vcpkg.json
+@@ -4,7 +4,7 @@
+   "port-version": 1,
+   "description": "C99 implementation of the HTTP/1.1 and HTTP/2 specifications",
+   "homepage": "https://github.com/awslabs/aws-c-http",
+-  "supports": "!arm & !uwp",
++  "supports": "!uwp",
+   "dependencies": [
+     "aws-c-cal",
+     "aws-c-common",
+diff --git a/ports/aws-c-io/vcpkg.json b/ports/aws-c-io/vcpkg.json
+index 60a1fb93..b695deb5 100644
+--- a/ports/aws-c-io/vcpkg.json
++++ b/ports/aws-c-io/vcpkg.json
+@@ -4,7 +4,7 @@
+   "port-version": 1,
+   "description": "Handles all IO and TLS work for application protocols.",
+   "homepage": "https://github.com/awslabs/aws-c-io",
+-  "supports": "!arm & !uwp",
++  "supports": "!uwp",
+   "dependencies": [
+     "aws-c-cal",
+     "aws-c-common",
+diff --git a/ports/aws-c-mqtt/vcpkg.json b/ports/aws-c-mqtt/vcpkg.json
+index de7e464e..3f459a79 100644
+--- a/ports/aws-c-mqtt/vcpkg.json
++++ b/ports/aws-c-mqtt/vcpkg.json
+@@ -4,7 +4,7 @@
+   "port-version": 1,
+   "description": "C99 implementation of the MQTT 3.1.1 specification.",
+   "homepage": "https://github.com/awslabs/aws-c-mqtt",
+-  "supports": "!arm & !uwp",
++  "supports": "!uwp",
+   "dependencies": [
+     {
+       "name": "s2n",
+diff --git a/ports/aws-c-s3/vcpkg.json b/ports/aws-c-s3/vcpkg.json
+index 31dba925..902c07f9 100644
+--- a/ports/aws-c-s3/vcpkg.json
++++ b/ports/aws-c-s3/vcpkg.json
+@@ -4,7 +4,7 @@
+   "port-version": 1,
+   "description": "C99 library implementation for communicating with the S3 service, designed for maximizing throughput on high bandwidth EC2 instances.",
+   "homepage": "https://github.com/awslabs/aws-c-s3",
+-  "supports": "!arm & !uwp",
++  "supports": "!uwp",
+   "dependencies": [
+     "aws-c-auth",
+     "aws-c-cal",
+diff --git a/ports/aws-checksums/vcpkg.json b/ports/aws-checksums/vcpkg.json
+index 3cdea453..1cbed512 100644
+--- a/ports/aws-checksums/vcpkg.json
++++ b/ports/aws-checksums/vcpkg.json
+@@ -4,7 +4,6 @@
+   "port-version": 2,
+   "description": "Cross-Platform HW accelerated CRC32c and CRC32 with fallback to efficient SW implementations.",
+   "homepage": "https://github.com/awslabs/aws-checksums",
+-  "supports": "!arm",
+   "dependencies": [
+     "aws-c-common",
+     {
+diff --git a/ports/aws-crt-cpp/vcpkg.json b/ports/aws-crt-cpp/vcpkg.json
+index 3b8cfafd..38c37ec9 100644
+--- a/ports/aws-crt-cpp/vcpkg.json
++++ b/ports/aws-crt-cpp/vcpkg.json
+@@ -4,7 +4,7 @@
+   "port-version": 2,
+   "description": "Cross-Platform HW accelerated CRC32c and CRC32 with fallback to efficient SW implementations.",
+   "homepage": "https://github.com/awslabs/aws-crt-cpp",
+-  "supports": "!arm & !uwp",
++  "supports": "!uwp",
+   "dependencies": [
+     "aws-c-auth",
+     "aws-c-cal",
+diff --git a/ports/aws-sdk-cpp/fix-find-crypto.patch b/ports/aws-sdk-cpp/fix-find-crypto.patch
+new file mode 100644
+index 00000000..4566cc66
+--- /dev/null
++++ b/ports/aws-sdk-cpp/fix-find-crypto.patch
+@@ -0,0 +1,20 @@
++diff --git a/cmake/setup_cmake_find_module.cmake b/cmake/setup_cmake_find_module.cmake
++index f5f147a0f..4561b8c39 100644
++--- a/cmake/setup_cmake_find_module.cmake
+++++ b/cmake/setup_cmake_find_module.cmake
++@@ -30,15 +30,6 @@ file(WRITE
++     "set(AWSSDK_INSTALL_BINDIR ${BINARY_DIRECTORY})\n"
++     "set(AWSSDK_INSTALL_INCLUDEDIR ${INCLUDE_DIRECTORY})\n"
++     "set(AWSSDK_INSTALL_ARCHIVEDIR ${ARCHIVE_DIRECTORY})\n"
++-    "if (NOT LibCrypto_INCLUDE_DIR)\n"
++-    "    set(LibCrypto_INCLUDE_DIR ${OPENSSL_INCLUDE_DIR} CACHE INTERNAL \"The OpenSSL include directory\")\n"
++-    "endif()\n"
++-    "if (NOT LibCrypto_STATIC_LIBRARY)\n"
++-    "    set(LibCrypto_STATIC_LIBRARY ${OPENSSL_CRYPTO_LIBRARY} CACHE INTERNAL \"The OpenSSL crypto static library\")\n"
++-    "endif()\n"
++-    "if (NOT LibCrypto_SHARED_LIBRARY)\n"
++-    "    set(LibCrypto_SHARED_LIBRARY ${OPENSSL_CRYPTO_LIBRARY} CACHE INTERNAL \"The OpenSSL crypto shared library\")\n"
++-    "endif()\n"
++     )
++ 
++ if (NOT SIMPLE_INSTALL)
+diff --git a/ports/aws-sdk-cpp/portfile.cmake b/ports/aws-sdk-cpp/portfile.cmake
+index 2d6bba4d..0ac47887 100644
+--- a/ports/aws-sdk-cpp/portfile.cmake
++++ b/ports/aws-sdk-cpp/portfile.cmake
+@@ -8,6 +8,7 @@ vcpkg_from_github(
+     PATCHES
+         patch-relocatable-rpath.patch
+         fix-aws-root.patch
++        fix-find-crypto.patch
+ )
+ 
+ string(COMPARE EQUAL "${VCPKG_CRT_LINKAGE}" "dynamic" FORCE_SHARED_CRT)
+diff --git a/ports/aws-sdk-cpp/vcpkg.json b/ports/aws-sdk-cpp/vcpkg.json
+index 3836e2b6..cd88ef07 100644
+--- a/ports/aws-sdk-cpp/vcpkg.json
++++ b/ports/aws-sdk-cpp/vcpkg.json
+@@ -5,7 +5,7 @@
+   "port-version": 5,
+   "description": "AWS SDK for C++",
+   "homepage": "https://github.com/aws/aws-sdk-cpp",
+-  "supports": "!arm & !uwp",
++  "supports": "!uwp",
+   "dependencies": [
+     "aws-crt-cpp",
+     {
 diff --git a/ports/curl/portfile.cmake b/ports/curl/portfile.cmake
-index be66d452be..a5ce325e9d 100644
+index ce8b7570..8255ba24 100644
 --- a/ports/curl/portfile.cmake
 +++ b/ports/curl/portfile.cmake
-@@ -94,6 +94,8 @@ vcpkg_configure_cmake(
+@@ -92,6 +92,10 @@ vcpkg_cmake_configure(
          -DCMAKE_DISABLE_FIND_PACKAGE_Perl=ON
          -DENABLE_DEBUG=ON
          -DCURL_CA_FALLBACK=ON
 +        -DCURL_CA_PATH=none
 +        -DCURL_CA_BUNDLE=none
-     OPTIONS_DEBUG
-         ${EXTRA_ARGS_DEBUG}
++    OPTIONS_DEBUG
++        ${EXTRA_ARGS_DEBUG}
      OPTIONS_RELEASE
+         ${OPTIONS_RELEASE}
+     OPTIONS_DEBUG
 diff --git a/ports/snappy/portfile.cmake b/ports/snappy/portfile.cmake
-index 75dd133027..84345c7caa 100644
+index 45b8c706..b409d8a7 100644
 --- a/ports/snappy/portfile.cmake
 +++ b/ports/snappy/portfile.cmake
 @@ -4,6 +4,7 @@ vcpkg_from_github(
-     REF 537f4ad6240e586970fe554614542e9717df7902 # 1.1.8
-     SHA512 555d3b69a6759592736cbaae8f41654f0cf14e8be693b5dde37640191e53daec189f895872557b173e905d10681ef502f3e6ed8566811add963ffef96ce4016d
+     REF 1.1.9
+     SHA512 f1f8a90f5f7f23310423574b1d8c9acb84c66ea620f3999d1060395205e5760883476837aba02f0aa913af60819e34c625d8308c18a5d7a9c4e190f35968b024
      HEAD_REF master
 +    PATCHES "snappy-disable-bmi.patch"
  )
-
- vcpkg_configure_cmake(
+ 
+ vcpkg_cmake_configure(
 diff --git a/ports/snappy/snappy-disable-bmi.patch b/ports/snappy/snappy-disable-bmi.patch
 new file mode 100644
-index 0000000000..2cbb1533a8
+index 00000000..a57ce0c2
 --- /dev/null
 +++ b/ports/snappy/snappy-disable-bmi.patch
-@@ -0,0 +1,17 @@
-+--- snappy.cc  2020-06-27 17:38:49.718993748 -0500
-++++ snappy.cc  2020-06-27 17:37:57.543268213 -0500
-+@@ -717,14 +717,10 @@
-+ static inline uint32 ExtractLowBytes(uint32 v, int n) {
+@@ -0,0 +1,19 @@
++diff --git a/snappy.cc b/snappy.cc
++index 79dc0e8..f3153ea 100644
++--- a/snappy.cc
+++++ b/snappy.cc
++@@ -965,14 +965,10 @@ static inline void Report(const char *algorithm, size_t compressed_size,
++ static inline uint32_t ExtractLowBytes(uint32_t v, int n) {
 +   assert(n >= 0);
 +   assert(n <= 4);
 +-#if SNAPPY_HAVE_BMI2
 +-  return _bzhi_u32(v, 8 * n);
 +-#else
-+   // This needs to be wider than uint32 otherwise `mask << 32` will be
++   // This needs to be wider than uint32_t otherwise `mask << 32` will be
 +   // undefined.
-+   uint64 mask = 0xffffffff;
++   uint64_t mask = 0xffffffff;
 +   return v & ~(mask << (8 * n));
 +-#endif
 + }
-+
-+ static inline bool LeftShiftOverflows(uint8 value, uint32 shift) {
++ 
++ static inline bool LeftShiftOverflows(uint8_t value, uint32_t shift) {
diff --git a/ci/vcpkg/universal2-osx-static-debug.cmake b/ci/vcpkg/universal2-osx-static-debug.cmake
index 706ac47a72c..29e4b0e63c5 100644
--- a/ci/vcpkg/universal2-osx-static-debug.cmake
+++ b/ci/vcpkg/universal2-osx-static-debug.cmake
@@ -20,7 +20,7 @@ set(VCPKG_CRT_LINKAGE dynamic)
 set(VCPKG_LIBRARY_LINKAGE static)
 
 set(VCPKG_CMAKE_SYSTEM_NAME Darwin)
-set(VCPKG_OSX_ARCHITECTURES "x86_64\;arm64")
+set(VCPKG_OSX_ARCHITECTURES "x86_64;arm64")
 set(VCPKG_OSX_DEPLOYMENT_TARGET "10.13")
 
 set(VCPKG_BUILD_TYPE debug)
diff --git a/ci/vcpkg/universal2-osx-static-release.cmake b/ci/vcpkg/universal2-osx-static-release.cmake
index 8670690171e..8111169fab2 100644
--- a/ci/vcpkg/universal2-osx-static-release.cmake
+++ b/ci/vcpkg/universal2-osx-static-release.cmake
@@ -20,7 +20,7 @@ set(VCPKG_CRT_LINKAGE dynamic)
 set(VCPKG_LIBRARY_LINKAGE static)
 
 set(VCPKG_CMAKE_SYSTEM_NAME Darwin)
-set(VCPKG_OSX_ARCHITECTURES "x86_64\;arm64")
+set(VCPKG_OSX_ARCHITECTURES "x86_64;arm64")
 set(VCPKG_OSX_DEPLOYMENT_TARGET "10.13")
 
 set(VCPKG_BUILD_TYPE release)
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index f3d6b24c48f..0262357d6c7 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -765,6 +765,13 @@ if(ARROW_S3)
   list(APPEND ARROW_STATIC_LINK_LIBS ${AWSSDK_LINK_LIBRARIES})
 endif()
 
+if(ARROW_WITH_OPENTELEMETRY)
+  list(APPEND ARROW_LINK_LIBS opentelemetry-cpp::trace
+       opentelemetry-cpp::otlp_http_exporter)
+  list(APPEND ARROW_STATIC_LINK_LIBS opentelemetry-cpp::trace
+       opentelemetry-cpp::otlp_http_exporter)
+endif()
+
 if(ARROW_WITH_UTF8PROC)
   list(APPEND ARROW_LINK_LIBS utf8proc::utf8proc)
   list(APPEND ARROW_STATIC_LINK_LIBS utf8proc::utf8proc)
diff --git a/cpp/CMakePresets.json b/cpp/CMakePresets.json
index a9ca585abdc..ebb3d86283b 100644
--- a/cpp/CMakePresets.json
+++ b/cpp/CMakePresets.json
@@ -1,165 +1,266 @@
-{
-  "version": 2,
-  "cmakeMinimumRequired": {
-    "major": 3,
-    "minor": 20,
-    "patch": 0
-  },
-  "configurePresets": [
-    {
-      "name": "ninja-benchmarks",
-      "description": "Build for benchmarks",
-      "inherits": "ninja-release",
-      "cacheVariables": {
-        "ARROW_BUILD_BENCHMARKS": "ON",
-        "ARROW_BUILD_BENCHMARKS_REFERENCE": "ON",
-        "ARROW_BUILD_TESTS": "OFF"
-      }
-    },
-    {
-      "name": "ninja-debug",
-      "description": "Debug configuration with basic build",
-      "binaryDir": "${sourceDir}/build/${presetName}",
-      "generator": "Ninja",
-      "cacheVariables": {
-        "ARROW_BUILD_BENCHMARKS": {
-          "type": "BOOL",
-          "value": "OFF"
-        },
-        "ARROW_BUILD_TESTS": {
-          "type": "BOOL",
-          "value": "ON"
-        },
-        "ARROW_COMPUTE": {
-          "type": "BOOL",
-          "value": "ON"
-        },
-        "ARROW_CSV": {
-          "type": "BOOL",
-          "value": "ON"
-        },
-        "ARROW_CUDA": {
-          "type": "BOOL",
-          "value": "OFF"
-        },
-        "ARROW_DATASET": {
-          "type": "BOOL",
-          "value": "OFF"
-        },
-        "ARROW_GANDIVA": {
-          "type": "BOOL",
-          "value": "OFF"
-        },
-        "ARROW_GANDIVA_JAVA": {
-          "type": "BOOL",
-          "value": "OFF"
-        },
-        "ARROW_GANDIVA_JNI": {
-          "type": "BOOL",
-          "value": "OFF"
-        },
-        "ARROW_FILESYSTEM": {
-          "type": "BOOL",
-          "value": "ON"
-        },
-        "ARROW_IPC": {
-          "type": "BOOL",
-          "value": "ON"
-        },
-        "ARROW_PARQUET": {
-          "type": "BOOL",
-          "value": "OFF"
-        },
-        "ARROW_PLASMA_JAVA_CLIENT": {
-          "type": "BOOL",
-          "value": "OFF"
-        },
-        "ARROW_PYTHON": {
-          "type": "BOOL",
-          "value": "ON"
-        },
-        "ARROW_SKYHOOK": {
-          "type": "BOOL",
-          "value": "OFF"
-        },
-        "ARROW_WITH_RE2": {
-          "type": "BOOL",
-          "value": "ON"
-        },
-        "CMAKE_BUILD_TYPE": {
-          "type": "String",
-          "value": "Debug"
-        },
-        "CMAKE_INSTALL_PREFIX": {
-          "type": "PATH",
-          "value": "${sourceDir}/build/${presetName}/pkg"
-        }
-      }
-    },
-    {
-      "name": "ninja-debug-cuda",
-      "description": "Debug Arrow build with CUDA extensions (requires CUDA toolkit)",
-      "inherits": "ninja-debug",
-      "cacheVariables": {
-        "ARROW_CUDA": "ON"
-      }
-    },
-    {
-      "name": "ninja-debug-dataset",
-      "description": "Builds Arrow Dataset modules",
-      "inherits": "ninja-debug",
-      "cacheVariables": {
-        "ARROW_DATASET": "ON"
-      }
-    },
-    {
-      "name": "ninja-debug-gandiva",
-      "description": "Builds Gandiva libraries",
-      "inherits": "ninja-debug",
-      "cacheVariables": {
-        "ARROW_GANDIVA": "ON"
-      }
-    },
-    {
-      "name": "ninja-debug-parquet",
-      "description": "Builds Parquet libraries",
-      "inherits": "ninja-debug",
-      "cacheVariables": {
-        "ARROW_PARQUET": "ON"
-      }
-    },
-    {
-      "name": "ninja-debug-skyhook",
-      "description": "Builds Skyhook libraries",
-
-      "inherits": "ninja-debug",
-      "cacheVariables": {
-        "ARROW_SKYHOOK": "ON"
-      }
-    },
-    {
-      "name": "ninja-release",
-      "description": "Release configuration",
-      "inherits": "ninja-debug",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Release"
-      }
-    },
-    {
-      "name": "ninja-release-gandiva",
-      "description": "Release configuration with Gandiva",
-      "inherits": "ninja-release",
-      "cacheVariables": {
-        "ARROW_GANDIVA": "ON"
-      }
-    },
-    {
-      "name": "ninja-release-parquet",
-      "description": "Release configuration with Parquet",
-      "inherits": "ninja-release",
-      "cacheVariables": {
-        "ARROW_PARQUET": "ON"
-      }
-    }
-  ]
-}
+{
+  "version": 3,
+  "cmakeMinimumRequired": {
+    "major": 3,
+    "minor": 21,
+    "patch": 0
+  },
+  "configurePresets": [
+    {
+      "name": "base",
+      "hidden": true,
+      "generator": "Ninja",
+      "cacheVariables": {
+        "ARROW_BUILD_STATIC": "OFF"
+      }
+    },
+    {
+      "name": "base-debug",
+      "inherits": "base",
+      "hidden": true,
+      "cacheVariables": {
+        "ARROW_BUILD_INTEGRATION": "ON",
+        "ARROW_BUILD_TESTS": "ON",
+        "ARROW_EXTRA_ERROR_CONTEXT": "ON",
+        "CMAKE_BUILD_TYPE": "Debug"
+      }
+    },
+    {
+      "name": "base-release",
+      "inherits": "base",
+      "hidden": true,
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release"
+      }
+    },
+    {
+      "name": "base-benchmarks",
+      "inherits": "base",
+      "hidden": true,
+      "cacheVariables": {
+        "ARROW_BUILD_BENCHMARKS": "ON",
+        "ARROW_BUILD_BENCHMARKS_REFERENCE": "ON",
+        "CMAKE_BUILD_TYPE": "RelWithDebInfo"
+      }
+    },
+    {
+      "name": "features-minimal",
+      "hidden": true,
+      "cacheVariables": {
+        "ARROW_WITH_RE2": "OFF",
+        "ARROW_WITH_UTF8PROC": "OFF"
+      }
+    },
+    {
+      "name": "features-basic",
+      "inherits": "features-minimal",
+      "hidden": true,
+      "cacheVariables": {
+        "ARROW_COMPUTE": "ON",
+        "ARROW_CSV": "ON",
+        "ARROW_DATASET": "ON",
+        "ARROW_FILESYSTEM": "ON",
+        "ARROW_JSON": "ON"
+      }
+    },
+    {
+      "name": "features-main",
+      "inherits": "features-basic",
+      "hidden": true,
+      "cacheVariables": {
+        "ARROW_ENGINE": "ON",
+        "ARROW_MIMALLOC": "ON",
+        "ARROW_PARQUET": "ON",
+        "ARROW_WITH_BROTLI": "ON",
+        "ARROW_WITH_BZ2": "ON",
+        "ARROW_WITH_LZ4": "ON",
+        "ARROW_WITH_RE2": "ON",
+        "ARROW_WITH_SNAPPY": "ON",
+        "ARROW_WITH_UTF8PROC": "ON",
+        "ARROW_WITH_ZLIB": "ON",
+        "ARROW_WITH_ZSTD": "ON"
+      }
+    },
+    {
+      "name": "features-cuda",
+      "inherits": "features-basic",
+      "hidden": true,
+      "cacheVariables": {
+        "ARROW_CUDA": "ON"
+      }
+    },
+    {
+      "name": "features-filesystems",
+      "inherits": "features-basic",
+      "hidden": true,
+      "cacheVariables": {
+        "ARROW_GCS": "ON",
+        "ARROW_HDFS": "ON",
+        "ARROW_S3": "ON"
+      }
+    },
+    {
+      "name": "features-flight",
+      "inherits": "features-basic",
+      "hidden": true,
+      "cacheVariables": {
+        "ARROW_FLIGHT": "ON"
+      }
+    },
+    {
+      "name": "features-gandiva",
+      "inherits": "features-basic",
+      "hidden": true,
+      "cacheVariables": {
+        "ARROW_GANDIVA": "ON"
+      }
+    },
+    {
+      "name": "features-python",
+      "inherits": "features-main",
+      "hidden": true,
+      "cacheVariables": {
+        "ARROW_PYTHON": "ON"
+      }
+    },
+    {
+      "name": "features-maximal",
+      "inherits": ["features-main", "features-cuda",
+                   "features-filesystems", "features-flight",
+                   "features-gandiva", "features-python"],
+      "hidden": true,
+      "displayName": "Debug build with everything enabled (except benchmarks and CUDA)",
+      "cacheVariables": {
+        "ARROW_BUILD_EXAMPLES": "ON",
+        "ARROW_BUILD_UTILITIES": "ON",
+        "ARROW_HIVESERVER2": "ON",
+        "ARROW_ORC": "ON",
+        "ARROW_SKYHOOK": "ON",
+        "ARROW_TENSORFLOW": "ON",
+        "PARQUET_BUILD_EXAMPLES": "ON",
+        "PARQUET_BUILD_EXECUTABLES": "ON",
+        "PARQUET_REQUIRE_ENCRYPTION": "ON"
+      }
+    },
+
+    {
+      "name": "ninja-debug-minimal",
+      "inherits": ["base-debug", "features-minimal"],
+      "displayName": "Debug build without anything enabled",
+      "cacheVariables": {
+        "ARROW_BUILD_INTEGRATION": "OFF",
+        "ARROW_BUILD_TESTS": "OFF"
+      }
+    },
+    {
+      "name": "ninja-debug-basic",
+      "inherits": ["base-debug", "features-basic"],
+      "displayName": "Debug build with tests and reduced dependencies",
+      "cacheVariables": {}
+    },
+    {
+      "name": "ninja-debug",
+      "inherits": ["base-debug", "features-main"],
+      "displayName": "Debug build with tests and more optional components",
+      "cacheVariables": {}
+    },
+    {
+      "name": "ninja-debug-cuda",
+      "inherits": ["base-debug", "features-cuda"],
+      "displayName": "Debug build with tests and CUDA integration",
+      "cacheVariables": {}
+    },
+    {
+      "name": "ninja-debug-filesystems",
+      "inherits": ["base-debug", "features-filesystems"],
+      "displayName": "Debug build with tests and filesystems",
+      "cacheVariables": {}
+    },
+    {
+      "name": "ninja-debug-flight",
+      "inherits": ["base-debug", "features-flight"],
+      "displayName": "Debug build with tests and Flight",
+      "cacheVariables": {}
+    },
+    {
+      "name": "ninja-debug-gandiva",
+      "inherits": ["base-debug", "features-gandiva"],
+      "displayName": "Debug build with tests and Gandiva",
+      "cacheVariables": {}
+    },
+    {
+      "name": "ninja-debug-python",
+      "inherits": ["base-debug", "features-python"],
+      "displayName": "Debug build with tests and Python support",
+      "cacheVariables": {}
+    },
+    {
+      "name": "ninja-debug-maximal",
+      "inherits": ["base-debug", "features-maximal"],
+      "displayName": "Debug build with everything enabled (except benchmarks and CUDA)",
+      "cacheVariables": {}
+    },
+
+    {
+      "name": "ninja-release-minimal",
+      "inherits": ["base-release", "features-minimal"],
+      "displayName": "Release build without anything enabled",
+      "cacheVariables": {}
+    },
+    {
+      "name": "ninja-release-basic",
+      "inherits": ["base-release", "features-basic"],
+      "displayName": "Release build with reduced dependencies",
+      "cacheVariables": {}
+    },
+    {
+      "name": "ninja-release",
+      "inherits": ["base-release", "features-main"],
+      "displayName": "Release build with more optional components",
+      "cacheVariables": {}
+    },
+    {
+      "name": "ninja-release-cuda",
+      "inherits": ["base-release", "features-cuda"],
+      "displayName": "Release build with CUDA integration",
+      "cacheVariables": {}
+    },
+    {
+      "name": "ninja-release-flight",
+      "inherits": ["base-release", "features-flight"],
+      "displayName": "Release build with Flight",
+      "cacheVariables": {}
+    },
+    {
+      "name": "ninja-release-gandiva",
+      "inherits": ["base-release", "features-gandiva"],
+      "displayName": "Release build with Gandiva",
+      "cacheVariables": {}
+    },
+    {
+      "name": "ninja-release-python",
+      "inherits": ["base-release", "features-python"],
+      "displayName": "Release build with Python support",
+      "cacheVariables": {}
+    },
+    {
+      "name": "ninja-release-maximal",
+      "inherits": ["base-release", "features-maximal"],
+      "displayName": "Release build with everything enabled (except benchmarks and CUDA)",
+      "cacheVariables": {}
+    },
+
+    {
+      "name": "ninja-benchmarks-basic",
+      "inherits": ["base-benchmarks", "features-basic"],
+      "displayName": "Benchmarking build with reduced dependencies",
+      "cacheVariables": {}
+    },
+    {
+      "name": "ninja-benchmarks",
+      "inherits": ["base-benchmarks", "features-main"],
+      "displayName": "Benchmarking build with more optional components",
+      "cacheVariables": {}
+    }
+  ]
+}
diff --git a/cpp/cmake_modules/DefineOptions.cmake b/cpp/cmake_modules/DefineOptions.cmake
index f81a1b15779..f2ddff3997d 100644
--- a/cpp/cmake_modules/DefineOptions.cmake
+++ b/cpp/cmake_modules/DefineOptions.cmake
@@ -219,6 +219,8 @@ if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
 
   define_option(ARROW_DATASET "Build the Arrow Dataset Modules" OFF)
 
+  define_option(ARROW_ENGINE "Build the Arrow Execution Engine" OFF)
+
   define_option(ARROW_FILESYSTEM "Build the Arrow Filesystem Layer" OFF)
 
   define_option(ARROW_FLIGHT
@@ -371,6 +373,9 @@ if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
 
   define_option(ARROW_WITH_BACKTRACE "Build with backtrace support" ON)
 
+  define_option(ARROW_WITH_OPENTELEMETRY
+                "Build libraries with OpenTelemetry support for distributed tracing" OFF)
+
   define_option(ARROW_WITH_BROTLI "Build with Brotli compression" OFF)
   define_option(ARROW_WITH_BZ2 "Build with BZ2 compression" OFF)
   define_option(ARROW_WITH_LZ4 "Build with lz4 compression" OFF)
diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index 72bd1705e04..267024ce63b 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -63,6 +63,7 @@ set(ARROW_THIRDPARTY_DEPENDENCIES
     GTest
     LLVM
     Lz4
+    opentelemetry-cpp
     ORC
     re2
     Protobuf
@@ -160,6 +161,8 @@ macro(build_dependency DEPENDENCY_NAME)
     build_gtest()
   elseif("${DEPENDENCY_NAME}" STREQUAL "Lz4")
     build_lz4()
+  elseif("${DEPENDENCY_NAME}" STREQUAL "opentelemetry-cpp")
+    build_opentelemetry()
   elseif("${DEPENDENCY_NAME}" STREQUAL "ORC")
     build_orc()
   elseif("${DEPENDENCY_NAME}" STREQUAL "Protobuf")
@@ -269,6 +272,11 @@ if(PARQUET_REQUIRE_ENCRYPTION)
   set(ARROW_JSON ON)
 endif()
 
+if(ARROW_WITH_OPENTELEMETRY)
+  set(ARROW_WITH_GRPC ON)
+  set(ARROW_WITH_PROTOBUF ON)
+endif()
+
 if(ARROW_THRIFT)
   set(ARROW_WITH_ZLIB ON)
 endif()
@@ -286,7 +294,9 @@ endif()
 
 if(ARROW_FLIGHT)
   set(ARROW_WITH_GRPC ON)
-  # gRPC requires zlib
+endif()
+
+if(ARROW_WITH_GRPC)
   set(ARROW_WITH_ZLIB ON)
 endif()
 
@@ -546,6 +556,25 @@ else()
   )
 endif()
 
+if(DEFINED ENV{ARROW_OPENTELEMETRY_URL})
+  set(OPENTELEMETRY_SOURCE_URL "$ENV{ARROW_OPENTELEMETRY_URL}")
+else()
+  # TODO: add mirror
+  set_urls(OPENTELEMETRY_SOURCE_URL
+           "https://github.com/open-telemetry/opentelemetry-cpp/archive/refs/tags/${ARROW_OPENTELEMETRY_BUILD_VERSION}.tar.gz"
+  )
+endif()
+
+if(DEFINED ENV{ARROW_OPENTELEMETRY_PROTO_URL})
+  set(OPENTELEMETRY_PROTO_SOURCE_URL "$ENV{ARROW_OPENTELEMETRY_PROTO_URL}")
+else()
+  # TODO: add mirror
+  # N.B. upstream pins to particular commits, not tags
+  set_urls(OPENTELEMETRY_PROTO_SOURCE_URL
+           "https://github.com/open-telemetry/opentelemetry-proto/archive/${ARROW_OPENTELEMETRY_PROTO_BUILD_VERSION}.tar.gz"
+  )
+endif()
+
 if(DEFINED ENV{ARROW_PROTOBUF_URL})
   set(PROTOBUF_SOURCE_URL "$ENV{ARROW_PROTOBUF_URL}")
 else()
@@ -969,6 +998,23 @@ if(ARROW_BOOST_REQUIRED)
   include_directories(SYSTEM ${Boost_INCLUDE_DIR})
 endif()
 
+# ----------------------------------------------------------------------
+# cURL
+
+macro(find_curl)
+  if(NOT TARGET CURL::libcurl)
+    find_package(CURL REQUIRED)
+    if(NOT TARGET CURL::libcurl)
+      # For CMake 3.11 or older
+      add_library(CURL::libcurl UNKNOWN IMPORTED)
+      set_target_properties(CURL::libcurl
+                            PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+                                       "${CURL_INCLUDE_DIRS}" IMPORTED_LOCATION
+                                                              "${CURL_LIBRARIES}")
+    endif()
+  endif()
+endmacro()
+
 # ----------------------------------------------------------------------
 # Snappy
 
@@ -1931,8 +1977,7 @@ macro(build_benchmark)
 endmacro()
 
 if(ARROW_BUILD_BENCHMARKS)
-  # ArgsProduct() is available since 1.5.2
-  set(BENCHMARK_REQUIRED_VERSION 1.5.2)
+  set(BENCHMARK_REQUIRED_VERSION 1.6.0)
   resolve_dependency(benchmark
                      REQUIRED_VERSION
                      ${BENCHMARK_REQUIRED_VERSION}
@@ -3600,8 +3645,11 @@ macro(build_nlohmann_json_once)
     set(NLOHMANN_JSON_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/nlohmann_json_ep-install")
     set(NLOHMANN_JSON_INCLUDE_DIR "${NLOHMANN_JSON_PREFIX}/include")
     set(NLOHMANN_JSON_CMAKE_ARGS
-        ${EP_COMMON_CMAKE_ARGS} -DCMAKE_CXX_STANDARD=11
-        "-DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>" -DBUILD_TESTING=OFF)
+        ${EP_COMMON_CMAKE_ARGS}
+        -DCMAKE_CXX_STANDARD=11
+        "-DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>"
+        -DBUILD_TESTING=OFF
+        -DJSON_BuildTests=OFF)
 
     set(NLOHMANN_JSON_BUILD_BYPRODUCTS ${NLOHMANN_JSON_PREFIX}/include/nlohmann/json.hpp)
 
@@ -3635,7 +3683,7 @@ macro(build_google_cloud_cpp_storage)
 
   # Curl is required on all platforms, but building it internally might also trip over S3's copy.
   # For now, force its inclusion from the underlying system or fail.
-  find_package(CURL 7.47.0 REQUIRED)
+  find_curl()
   find_package(OpenSSL ${ARROW_OPENSSL_REQUIRED_VERSION} REQUIRED)
 
   # Build google-cloud-cpp, with only storage_client
@@ -3672,19 +3720,6 @@ macro(build_google_cloud_cpp_storage)
   add_dependencies(google_cloud_cpp_dependencies absl_ep)
   add_dependencies(google_cloud_cpp_dependencies crc32c_ep)
   add_dependencies(google_cloud_cpp_dependencies nlohmann_json_ep)
-  # Typically the steps to build the AWKSSDK provide `CURL::libcurl`, but if that is
-  # disabled we need to provide our own.
-  if(NOT TARGET CURL::libcurl)
-    find_package(CURL REQUIRED)
-    if(NOT TARGET CURL::libcurl)
-      # For CMake 3.11 or older
-      add_library(CURL::libcurl UNKNOWN IMPORTED)
-      set_target_properties(CURL::libcurl
-                            PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
-                                       "${CURL_INCLUDE_DIRS}" IMPORTED_LOCATION
-                                                              "${CURL_LIBRARIES}")
-    endif()
-  endif()
 
   set(GOOGLE_CLOUD_CPP_STATIC_LIBRARY_STORAGE
       "${GOOGLE_CLOUD_CPP_INSTALL_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}google_cloud_cpp_storage${CMAKE_STATIC_LIBRARY_SUFFIX}"
@@ -3865,6 +3900,204 @@ if(ARROW_ORC)
   message(STATUS "Found ORC headers: ${ORC_INCLUDE_DIR}")
 endif()
 
+# ----------------------------------------------------------------------
+# OpenTelemetry C++
+
+macro(build_opentelemetry)
+  message("Building OpenTelemetry from source")
+
+  build_nlohmann_json_once()
+  find_curl()
+
+  set(OPENTELEMETRY_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/opentelemetry_ep-install")
+  set(OPENTELEMETRY_INCLUDE_DIR "${OPENTELEMETRY_PREFIX}/include")
+  set(OPENTELEMETRY_STATIC_LIB
+      "${OPENTELEMETRY_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}opentelemetry${CMAKE_STATIC_LIBRARY_SUFFIX}"
+  )
+  set(_OPENTELEMETRY_APIS api ext sdk)
+  set(_OPENTELEMETRY_LIBS
+      common
+      http_client_curl
+      ostream_span_exporter
+      otlp_http_exporter
+      otlp_recordable
+      proto
+      resources
+      trace
+      version)
+  set(OPENTELEMETRY_BUILD_BYPRODUCTS)
+  set(OPENTELEMETRY_LIBRARIES)
+
+  foreach(_OPENTELEMETRY_LIB ${_OPENTELEMETRY_APIS})
+    add_library(opentelemetry-cpp::${_OPENTELEMETRY_LIB} INTERFACE IMPORTED)
+    set_target_properties(opentelemetry-cpp::${_OPENTELEMETRY_LIB}
+                          PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+                                     "${OPENTELEMETRY_INCLUDE_DIR}")
+  endforeach()
+  foreach(_OPENTELEMETRY_LIB ${_OPENTELEMETRY_LIBS})
+    if(_OPENTELEMETRY_LIB STREQUAL "http_client_curl")
+      set(_OPENTELEMETRY_STATIC_LIBRARY
+          "${OPENTELEMETRY_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}${_OPENTELEMETRY_LIB}${CMAKE_STATIC_LIBRARY_SUFFIX}"
+      )
+    elseif(_OPENTELEMETRY_LIB STREQUAL "ostream_span_exporter")
+      set(_OPENTELEMETRY_STATIC_LIBRARY
+          "${OPENTELEMETRY_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}opentelemetry_exporter_ostream_span${CMAKE_STATIC_LIBRARY_SUFFIX}"
+      )
+    elseif(_OPENTELEMETRY_LIB STREQUAL "otlp_http_exporter")
+      set(_OPENTELEMETRY_STATIC_LIBRARY
+          "${OPENTELEMETRY_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}opentelemetry_exporter_otlp_http${CMAKE_STATIC_LIBRARY_SUFFIX}"
+      )
+    else()
+      set(_OPENTELEMETRY_STATIC_LIBRARY
+          "${OPENTELEMETRY_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}opentelemetry_${_OPENTELEMETRY_LIB}${CMAKE_STATIC_LIBRARY_SUFFIX}"
+      )
+    endif()
+    add_library(opentelemetry-cpp::${_OPENTELEMETRY_LIB} STATIC IMPORTED)
+    set_target_properties(opentelemetry-cpp::${_OPENTELEMETRY_LIB}
+                          PROPERTIES IMPORTED_LOCATION ${_OPENTELEMETRY_STATIC_LIBRARY})
+    list(APPEND OPENTELEMETRY_BUILD_BYPRODUCTS ${_OPENTELEMETRY_STATIC_LIBRARY})
+    list(APPEND OPENTELEMETRY_LIBRARIES opentelemetry-cpp::${_OPENTELEMETRY_LIB})
+  endforeach()
+
+  set(OPENTELEMETRY_CMAKE_ARGS
+      ${EP_COMMON_TOOLCHAIN}
+      "-DCMAKE_INSTALL_PREFIX=${OPENTELEMETRY_PREFIX}"
+      "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
+      -DCMAKE_INSTALL_LIBDIR=lib
+      "-DCMAKE_CXX_FLAGS=${EP_CXX_FLAGS}"
+      -DBUILD_TESTING=OFF
+      -DWITH_EXAMPLES=OFF)
+
+  set(OPENTELEMETRY_PREFIX_PATH_LIST)
+  # Don't specify the DEPENDS unless we actually have dependencies, else
+  # Ninja/other build systems may consider this target to always be dirty
+  set(_OPENTELEMETRY_DEPENDENCIES)
+  add_custom_target(opentelemetry_dependencies)
+
+  set(_OPENTELEMETRY_DEPENDENCIES "opentelemetry_dependencies")
+  list(APPEND ARROW_BUNDLED_STATIC_LIBS ${OPENTELEMETRY_LIBRARIES})
+  list(APPEND OPENTELEMETRY_PREFIX_PATH_LIST ${NLOHMANN_JSON_PREFIX})
+  list(APPEND
+       OPENTELEMETRY_CMAKE_ARGS
+       -DWITH_OTLP=ON
+       -DWITH_OTLP_HTTP=ON
+       -DWITH_OTLP_GRPC=OFF)
+
+  # OpenTelemetry with OTLP enabled requires Protobuf definitions from a
+  # submodule. This submodule path is hardcoded into their CMake definitions,
+  # and submodules are not included in their releases. Add a custom build step
+  # to download and extract the Protobufs.
+
+  # Adding such a step is rather complicated, so instead: create a separate
+  # ExternalProject that just fetches the Protobufs, then add a custom step
+  # to the main build to copy the Protobufs.
+  externalproject_add(opentelemetry_proto_ep
+                      ${EP_LOG_OPTIONS}
+                      URL_HASH "SHA256=${ARROW_OPENTELEMETRY_PROTO_BUILD_SHA256_CHECKSUM}"
+                      URL ${OPENTELEMETRY_PROTO_SOURCE_URL}
+                      BUILD_COMMAND ""
+                      CONFIGURE_COMMAND ""
+                      INSTALL_COMMAND ""
+                      EXCLUDE_FROM_ALL OFF)
+
+  add_dependencies(opentelemetry_dependencies nlohmann_json_ep opentelemetry_proto_ep)
+  if(gRPC_SOURCE STREQUAL "BUNDLED")
+    # TODO: opentelemetry-cpp::proto doesn't declare a dependency on gRPC, so
+    # even if we provide the location of gRPC, it'll fail to compile.
+    message(FATAL_ERROR "ARROW_WITH_OPENTELEMETRY cannot be configured with gRPC_SOURCE=BUNDLED. "
+                        "See https://github.com/open-telemetry/opentelemetry-cpp/issues/1045"
+    )
+  endif()
+
+  set(OPENTELEMETRY_PREFIX_PATH_LIST_SEP_CHAR "|")
+  # JOIN is CMake >=3.12 only
+  string(REPLACE ";" "${OPENTELEMETRY_PREFIX_PATH_LIST_SEP_CHAR}"
+                 OPENTELEMETRY_PREFIX_PATH "${OPENTELEMETRY_PREFIX_PATH_LIST}")
+  list(APPEND OPENTELEMETRY_CMAKE_ARGS "-DCMAKE_PREFIX_PATH=${OPENTELEMETRY_PREFIX_PATH}")
+
+  if(CMAKE_SYSTEM_PROCESSOR STREQUAL "s390x")
+    # OpenTelemetry tries to determine the processor arch for vcpkg, which fails
+    # on s390x, even though it doesn't use vcpkg there. Tell it ARCH manually
+    externalproject_add(opentelemetry_ep
+                        ${EP_LOG_OPTIONS}
+                        URL_HASH "SHA256=${ARROW_OPENTELEMETRY_BUILD_SHA256_CHECKSUM}"
+                        LIST_SEPARATOR ${OPENTELEMETRY_PREFIX_PATH_LIST_SEP_CHAR}
+                        CONFIGURE_COMMAND ${CMAKE_COMMAND} -E env ARCH=s390x
+                                          ${CMAKE_COMMAND} -G ${CMAKE_GENERATOR}
+                                          "<SOURCE_DIR><SOURCE_SUBDIR>"
+                                          ${OPENTELEMETRY_CMAKE_ARGS}
+                        BUILD_COMMAND ${CMAKE_COMMAND} --build "<BINARY_DIR>" --target all
+                        INSTALL_COMMAND ${CMAKE_COMMAND} --build "<BINARY_DIR>" --target
+                                        install
+                        URL ${OPENTELEMETRY_SOURCE_URL}
+                        BUILD_BYPRODUCTS ${OPENTELEMETRY_BUILD_BYPRODUCTS}
+                        EXCLUDE_FROM_ALL NOT
+                        ${ARROW_WITH_OPENTELEMETRY}
+                        DEPENDS ${_OPENTELEMETRY_DEPENDENCIES})
+  else()
+    externalproject_add(opentelemetry_ep
+                        ${EP_LOG_OPTIONS}
+                        URL_HASH "SHA256=${ARROW_OPENTELEMETRY_BUILD_SHA256_CHECKSUM}"
+                        LIST_SEPARATOR ${OPENTELEMETRY_PREFIX_PATH_LIST_SEP_CHAR}
+                        CMAKE_ARGS ${OPENTELEMETRY_CMAKE_ARGS}
+                        URL ${OPENTELEMETRY_SOURCE_URL}
+                        BUILD_BYPRODUCTS ${OPENTELEMETRY_BUILD_BYPRODUCTS}
+                        EXCLUDE_FROM_ALL NOT
+                        ${ARROW_WITH_OPENTELEMETRY}
+                        DEPENDS ${_OPENTELEMETRY_DEPENDENCIES})
+  endif()
+
+  externalproject_add_step(opentelemetry_ep download_proto
+                           COMMAND ${CMAKE_COMMAND} -E copy_directory
+                                   $<TARGET_PROPERTY:opentelemetry_proto_ep,_EP_SOURCE_DIR>/opentelemetry
+                                   $<TARGET_PROPERTY:opentelemetry_ep,_EP_SOURCE_DIR>/third_party/opentelemetry-proto/opentelemetry
+                           DEPENDEES download
+                           DEPENDERS configure)
+
+  add_dependencies(toolchain opentelemetry_ep)
+  add_dependencies(toolchain-tests opentelemetry_ep)
+
+  set(OPENTELEMETRY_VENDORED 1)
+
+  set_target_properties(opentelemetry-cpp::common
+                        PROPERTIES INTERFACE_LINK_LIBRARIES
+                                   "opentelemetry-cpp::api;opentelemetry-cpp::sdk;Threads::Threads"
+  )
+  set_target_properties(opentelemetry-cpp::resources
+                        PROPERTIES INTERFACE_LINK_LIBRARIES "opentelemetry-cpp::common")
+  set_target_properties(opentelemetry-cpp::trace
+                        PROPERTIES INTERFACE_LINK_LIBRARIES
+                                   "opentelemetry-cpp::common;opentelemetry-cpp::resources"
+  )
+  set_target_properties(opentelemetry-cpp::http_client_curl
+                        PROPERTIES INTERFACE_LINK_LIBRARIES
+                                   "opentelemetry-cpp::ext;CURL::libcurl")
+  set_target_properties(opentelemetry-cpp::proto
+                        PROPERTIES INTERFACE_LINK_LIBRARIES
+                                   "${ARROW_PROTOBUF_LIBPROTOBUF}")
+  set_target_properties(opentelemetry-cpp::otlp_recordable
+                        PROPERTIES INTERFACE_LINK_LIBRARIES
+                                   "opentelemetry-cpp::trace;opentelemetry-cpp::resources;opentelemetry-cpp::proto"
+  )
+  set_target_properties(opentelemetry-cpp::otlp_http_exporter
+                        PROPERTIES INTERFACE_LINK_LIBRARIES
+                                   "opentelemetry-cpp::otlp_recordable;opentelemetry-cpp::http_client_curl;nlohmann_json::nlohmann_json"
+  )
+
+  foreach(_OPENTELEMETRY_LIB ${_OPENTELEMETRY_LIBS})
+    add_dependencies(opentelemetry-cpp::${_OPENTELEMETRY_LIB} opentelemetry_ep)
+  endforeach()
+endmacro()
+
+if(ARROW_WITH_OPENTELEMETRY)
+  set(opentelemetry-cpp_SOURCE "AUTO")
+  resolve_dependency(opentelemetry-cpp)
+  get_target_property(OPENTELEMETRY_INCLUDE_DIR opentelemetry-cpp::api
+                      INTERFACE_INCLUDE_DIRECTORIES)
+  include_directories(SYSTEM ${OPENTELEMETRY_INCLUDE_DIR})
+  message(STATUS "Found OpenTelemetry headers: ${OPENTELEMETRY_INCLUDE_DIR}")
+endif()
+
 # ----------------------------------------------------------------------
 # AWS SDK for C++
 
@@ -4000,15 +4233,7 @@ macro(build_awssdk)
   set(AWSSDK_LINK_LIBRARIES ${AWSSDK_LIBRARIES})
   if(UNIX)
     # on Linux and macOS curl seems to be required
-    find_package(CURL REQUIRED)
-    if(NOT TARGET CURL::libcurl)
-      # For CMake 3.11 or older
-      add_library(CURL::libcurl UNKNOWN IMPORTED)
-      set_target_properties(CURL::libcurl
-                            PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
-                                       "${CURL_INCLUDE_DIRS}" IMPORTED_LOCATION
-                                                              "${CURL_LIBRARIES}")
-    endif()
+    find_curl()
     set_property(TARGET aws-cpp-sdk-core
                  APPEND
                  PROPERTY INTERFACE_LINK_LIBRARIES CURL::libcurl)
diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index 8d9cbb32300..5736c557bd0 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -287,6 +287,10 @@ if(ARROW_WITH_LZ4)
   list(APPEND ARROW_SRCS util/compression_lz4.cc)
 endif()
 
+if(ARROW_WITH_OPENTELEMETRY)
+  list(APPEND ARROW_SRCS util/tracing_internal.cc)
+endif()
+
 if(ARROW_WITH_SNAPPY)
   add_definitions(-DARROW_WITH_SNAPPY)
   list(APPEND ARROW_SRCS util/compression_snappy.cc)
diff --git a/cpp/src/arrow/array/array_base.h b/cpp/src/arrow/array/array_base.h
index 2add572e7a4..b6b769cf033 100644
--- a/cpp/src/arrow/array/array_base.h
+++ b/cpp/src/arrow/array/array_base.h
@@ -57,7 +57,7 @@ class ARROW_EXPORT Array {
   /// \brief Return true if value at index is null. Does not boundscheck
   bool IsNull(int64_t i) const {
     return null_bitmap_data_ != NULLPTR
-               ? !BitUtil::GetBit(null_bitmap_data_, i + data_->offset)
+               ? !bit_util::GetBit(null_bitmap_data_, i + data_->offset)
                : data_->null_count == data_->length;
   }
 
@@ -65,7 +65,7 @@ class ARROW_EXPORT Array {
   /// boundscheck
   bool IsValid(int64_t i) const {
     return null_bitmap_data_ != NULLPTR
-               ? BitUtil::GetBit(null_bitmap_data_, i + data_->offset)
+               ? bit_util::GetBit(null_bitmap_data_, i + data_->offset)
                : data_->null_count != data_->length;
   }
 
diff --git a/cpp/src/arrow/array/array_binary.h b/cpp/src/arrow/array/array_binary.h
index 19d3d65a464..04ee804987f 100644
--- a/cpp/src/arrow/array/array_binary.h
+++ b/cpp/src/arrow/array/array_binary.h
@@ -75,6 +75,10 @@ class BaseBinaryArray : public FlatArray {
                              raw_value_offsets_[i + 1] - pos);
   }
 
+  util::optional<util::string_view> operator[](int64_t i) const {
+    return *IteratorType(*this, i);
+  }
+
   /// \brief Get binary value as a string_view
   /// Provided for consistency with other arrays.
   ///
@@ -236,6 +240,10 @@ class ARROW_EXPORT FixedSizeBinaryArray : public PrimitiveArray {
     return util::string_view(reinterpret_cast<const char*>(GetValue(i)), byte_width());
   }
 
+  util::optional<util::string_view> operator[](int64_t i) const {
+    return *IteratorType(*this, i);
+  }
+
   std::string GetString(int64_t i) const { return std::string(GetView(i)); }
 
   int32_t byte_width() const { return byte_width_; }
diff --git a/cpp/src/arrow/array/array_binary_test.cc b/cpp/src/arrow/array/array_binary_test.cc
index 7840c60f897..e9f86df3fc4 100644
--- a/cpp/src/arrow/array/array_binary_test.cc
+++ b/cpp/src/arrow/array/array_binary_test.cc
@@ -106,6 +106,18 @@ class TestStringArray : public ::testing::Test {
     AssertZeroPadded(*strings_);
   }
 
+  void TestArrayIndexOperator() {
+    const auto& arr = *strings_;
+    for (int64_t i = 0; i < arr.length(); ++i) {
+      if (valid_bytes_[i]) {
+        ASSERT_TRUE(arr[i].has_value());
+        ASSERT_EQ(expected_[i], arr[i].value());
+      } else {
+        ASSERT_FALSE(arr[i].has_value());
+      }
+    }
+  }
+
   void TestArrayCtors() {
     // ARROW-8863: ArrayData::null_count set to 0 when no validity bitmap
     // provided
@@ -328,6 +340,8 @@ TYPED_TEST_SUITE(TestStringArray, BaseBinaryArrowTypes);
 
 TYPED_TEST(TestStringArray, TestArrayBasics) { this->TestArrayBasics(); }
 
+TYPED_TEST(TestStringArray, TestArrayIndexOperator) { this->TestArrayIndexOperator(); }
+
 TYPED_TEST(TestStringArray, TestArrayCtors) { this->TestArrayCtors(); }
 
 TYPED_TEST(TestStringArray, TestType) { this->TestType(); }
@@ -595,7 +609,7 @@ class TestStringBuilder : public TestBuilder {
     int reps = 15;
     int64_t length = 0;
     int64_t capacity = 1000;
-    int64_t expected_capacity = BitUtil::RoundUpToMultipleOf64(capacity);
+    int64_t expected_capacity = bit_util::RoundUpToMultipleOf64(capacity);
 
     ASSERT_OK(builder_->ReserveData(capacity));
 
@@ -613,7 +627,7 @@ class TestStringBuilder : public TestBuilder {
     }
 
     int extra_capacity = 500;
-    expected_capacity = BitUtil::RoundUpToMultipleOf64(length + extra_capacity);
+    expected_capacity = bit_util::RoundUpToMultipleOf64(length + extra_capacity);
 
     ASSERT_OK(builder_->ReserveData(extra_capacity));
 
diff --git a/cpp/src/arrow/array/array_dict_test.cc b/cpp/src/arrow/array/array_dict_test.cc
index d6f7f3c86f5..75f5205a10f 100644
--- a/cpp/src/arrow/array/array_dict_test.cc
+++ b/cpp/src/arrow/array/array_dict_test.cc
@@ -1141,7 +1141,7 @@ TEST(TestDictionary, FromArrays) {
     if (checked_cast<const IntegerType&>(*index_ty).is_signed()) {
       // Invalid index is masked by null, so it's OK
       auto indices3 = ArrayFromJSON(index_ty, "[1, 2, -1, null, 2, 0]");
-      BitUtil::ClearBit(indices3->data()->buffers[0]->mutable_data(), 2);
+      bit_util::ClearBit(indices3->data()->buffers[0]->mutable_data(), 2);
       ASSERT_OK_AND_ASSIGN(auto arr3,
                            DictionaryArray::FromArrays(dict_type, indices3, dict));
     }
diff --git a/cpp/src/arrow/array/array_list_test.cc b/cpp/src/arrow/array/array_list_test.cc
index 34887ad26fc..e1aaa310814 100644
--- a/cpp/src/arrow/array/array_list_test.cc
+++ b/cpp/src/arrow/array/array_list_test.cc
@@ -245,7 +245,7 @@ class TestListArray : public TestBuilder {
     AssertArraysEqual(expected3, *list3);
 
     // Check that the last offset bit is zero
-    ASSERT_FALSE(BitUtil::GetBit(list3->null_bitmap()->data(), length + 1));
+    ASSERT_FALSE(bit_util::GetBit(list3->null_bitmap()->data(), length + 1));
 
     ArrayType expected4(list_type, length, offsets2->data()->buffers[1], values,
                         offsets4->data()->buffers[0], 1);
@@ -425,9 +425,9 @@ class TestListArray : public TestBuilder {
     ASSERT_EQ(2, array_data->buffers.size());
     auto null_bitmap_buffer = array_data->buffers[0];
     ASSERT_NE(nullptr, null_bitmap_buffer);
-    BitUtil::ClearBit(null_bitmap_buffer->mutable_data(), 1);
-    BitUtil::ClearBit(null_bitmap_buffer->mutable_data(), 3);
-    BitUtil::ClearBit(null_bitmap_buffer->mutable_data(), 4);
+    bit_util::ClearBit(null_bitmap_buffer->mutable_data(), 1);
+    bit_util::ClearBit(null_bitmap_buffer->mutable_data(), 3);
+    bit_util::ClearBit(null_bitmap_buffer->mutable_data(), 4);
     array_data->null_count += 3;
     auto list_array = std::dynamic_pointer_cast<ArrayType>(MakeArray(array_data));
     ASSERT_OK(list_array->ValidateFull());
@@ -811,7 +811,7 @@ TEST_F(TestMapArray, FromArrays) {
   AssertArraysEqual(expected3, *map3);
 
   // Check that the last offset bit is zero
-  ASSERT_FALSE(BitUtil::GetBit(map3->null_bitmap()->data(), length + 1));
+  ASSERT_FALSE(bit_util::GetBit(map3->null_bitmap()->data(), length + 1));
 
   MapArray expected4(map_type, length, offsets2->data()->buffers[1], keys, items,
                      offsets4->data()->buffers[0], 1);
diff --git a/cpp/src/arrow/array/array_nested.cc b/cpp/src/arrow/array/array_nested.cc
index a3c1fab054e..c80273e9adf 100644
--- a/cpp/src/arrow/array/array_nested.cc
+++ b/cpp/src/arrow/array/array_nested.cc
@@ -75,7 +75,7 @@ Status CleanListOffsets(const Array& offsets, MemoryPool* pool,
     // we have N + 1 offsets)
     ARROW_ASSIGN_OR_RAISE(
         auto clean_valid_bits,
-        offsets.null_bitmap()->CopySlice(0, BitUtil::BytesForBits(num_offsets - 1)));
+        offsets.null_bitmap()->CopySlice(0, bit_util::BytesForBits(num_offsets - 1)));
     *validity_buf_out = clean_valid_bits;
 
     const offset_type* raw_offsets = typed_offsets.raw_values();
diff --git a/cpp/src/arrow/array/array_primitive.h b/cpp/src/arrow/array/array_primitive.h
index b5385f96514..740a4806a4d 100644
--- a/cpp/src/arrow/array/array_primitive.h
+++ b/cpp/src/arrow/array/array_primitive.h
@@ -48,12 +48,14 @@ class ARROW_EXPORT BooleanArray : public PrimitiveArray {
                int64_t null_count = kUnknownNullCount, int64_t offset = 0);
 
   bool Value(int64_t i) const {
-    return BitUtil::GetBit(reinterpret_cast<const uint8_t*>(raw_values_),
-                           i + data_->offset);
+    return bit_util::GetBit(reinterpret_cast<const uint8_t*>(raw_values_),
+                            i + data_->offset);
   }
 
   bool GetView(int64_t i) const { return Value(i); }
 
+  util::optional<bool> operator[](int64_t i) const { return *IteratorType(*this, i); }
+
   /// \brief Return the number of false (0) values among the valid
   /// values. Result is not cached.
   int64_t false_count() const;
@@ -109,6 +111,10 @@ class NumericArray : public PrimitiveArray {
   // For API compatibility with BinaryArray etc.
   value_type GetView(int64_t i) const { return Value(i); }
 
+  util::optional<value_type> operator[](int64_t i) const {
+    return *IteratorType(*this, i);
+  }
+
   IteratorType begin() const { return IteratorType(*this); }
 
   IteratorType end() const { return IteratorType(*this, length()); }
@@ -123,6 +129,7 @@ class NumericArray : public PrimitiveArray {
 class ARROW_EXPORT DayTimeIntervalArray : public PrimitiveArray {
  public:
   using TypeClass = DayTimeIntervalType;
+  using IteratorType = stl::ArrayIterator<DayTimeIntervalArray>;
 
   explicit DayTimeIntervalArray(const std::shared_ptr<ArrayData>& data);
 
@@ -141,6 +148,14 @@ class ARROW_EXPORT DayTimeIntervalArray : public PrimitiveArray {
   // For compatibility with Take kernel.
   TypeClass::DayMilliseconds GetView(int64_t i) const { return GetValue(i); }
 
+  IteratorType begin() const { return IteratorType(*this); }
+
+  IteratorType end() const { return IteratorType(*this, length()); }
+
+  util::optional<TypeClass::DayMilliseconds> operator[](int64_t i) const {
+    return *IteratorType(*this, i);
+  }
+
   int32_t byte_width() const { return sizeof(TypeClass::DayMilliseconds); }
 
   const uint8_t* raw_values() const { return raw_values_ + data_->offset * byte_width(); }
@@ -150,6 +165,7 @@ class ARROW_EXPORT DayTimeIntervalArray : public PrimitiveArray {
 class ARROW_EXPORT MonthDayNanoIntervalArray : public PrimitiveArray {
  public:
   using TypeClass = MonthDayNanoIntervalType;
+  using IteratorType = stl::ArrayIterator<MonthDayNanoIntervalArray>;
 
   explicit MonthDayNanoIntervalArray(const std::shared_ptr<ArrayData>& data);
 
@@ -168,6 +184,14 @@ class ARROW_EXPORT MonthDayNanoIntervalArray : public PrimitiveArray {
   // For compatibility with Take kernel.
   TypeClass::MonthDayNanos GetView(int64_t i) const { return GetValue(i); }
 
+  IteratorType begin() const { return IteratorType(*this); }
+
+  IteratorType end() const { return IteratorType(*this, length()); }
+
+  util::optional<TypeClass::MonthDayNanos> operator[](int64_t i) const {
+    return *IteratorType(*this, i);
+  }
+
   int32_t byte_width() const { return sizeof(TypeClass::MonthDayNanos); }
 
   const uint8_t* raw_values() const { return raw_values_ + data_->offset * byte_width(); }
diff --git a/cpp/src/arrow/array/array_test.cc b/cpp/src/arrow/array/array_test.cc
index efe600f1223..059757d1049 100644
--- a/cpp/src/arrow/array/array_test.cc
+++ b/cpp/src/arrow/array/array_test.cc
@@ -1050,7 +1050,7 @@ void TestPrimitiveBuilder<PBoolean>::Check(const std::unique_ptr<BooleanBuilder>
       ASSERT_FALSE(result->IsNull(i));
     }
     if (!result->IsNull(i)) {
-      bool actual = BitUtil::GetBit(result->values()->data(), i);
+      bool actual = bit_util::GetBit(result->values()->data(), i);
       ASSERT_EQ(draws_[i] != 0, actual) << i;
     }
   }
@@ -1058,11 +1058,11 @@ void TestPrimitiveBuilder<PBoolean>::Check(const std::unique_ptr<BooleanBuilder>
 
   // buffers are correctly sized
   if (result->data()->buffers[0]) {
-    ASSERT_EQ(result->data()->buffers[0]->size(), BitUtil::BytesForBits(size));
+    ASSERT_EQ(result->data()->buffers[0]->size(), bit_util::BytesForBits(size));
   } else {
     ASSERT_EQ(result->data()->null_count, 0);
   }
-  ASSERT_EQ(result->data()->buffers[1]->size(), BitUtil::BytesForBits(size));
+  ASSERT_EQ(result->data()->buffers[1]->size(), bit_util::BytesForBits(size));
 
   // Builder is now reset
   ASSERT_EQ(0, builder->length());
@@ -2162,6 +2162,16 @@ TEST_F(TestFWBinaryArray, ArrayDataVisitorSliced) {
   ARROW_UNUSED(visitor);  // Workaround weird MSVC warning
 }
 
+TEST_F(TestFWBinaryArray, ArrayIndexOperator) {
+  auto type = fixed_size_binary(3);
+  auto arr = ArrayFromJSON(type, R"(["abc", null, "def"])");
+  auto fsba = checked_pointer_cast<FixedSizeBinaryArray>(arr);
+
+  ASSERT_EQ("abc", (*fsba)[0].value());
+  ASSERT_EQ(util::nullopt, (*fsba)[1]);
+  ASSERT_EQ("def", (*fsba)[2].value());
+}
+
 // ----------------------------------------------------------------------
 // AdaptiveInt tests
 
@@ -3348,4 +3358,61 @@ TEST(TestSwapEndianArrayData, InvalidLength) {
   }
 }
 
+template <typename PType>
+class TestPrimitiveArray : public ::testing::Test {
+ public:
+  using ElementType = typename PType::T;
+
+  void SetUp() {
+    pool_ = default_memory_pool();
+    GenerateInput();
+  }
+
+  void GenerateInput() {
+    validity_ = std::vector<bool>{true, false, true, true, false, true};
+    values_ = std::vector<ElementType>{0, 1, 1, 0, 1, 1};
+  }
+
+ protected:
+  MemoryPool* pool_;
+  std::vector<bool> validity_;
+  std::vector<ElementType> values_;
+};
+
+template <>
+void TestPrimitiveArray<PDayTimeInterval>::GenerateInput() {
+  validity_ = std::vector<bool>{true, false};
+  values_ = std::vector<DayTimeIntervalType::DayMilliseconds>{{0, 10}, {1, 0}};
+}
+
+template <>
+void TestPrimitiveArray<PMonthDayNanoInterval>::GenerateInput() {
+  validity_ = std::vector<bool>{false, true};
+  values_ =
+      std::vector<MonthDayNanoIntervalType::MonthDayNanos>{{0, 10, 100}, {1, 0, 10}};
+}
+
+TYPED_TEST_SUITE(TestPrimitiveArray, Primitives);
+
+TYPED_TEST(TestPrimitiveArray, IndexOperator) {
+  typename TypeParam::BuilderType builder;
+  ASSERT_OK(builder.Reserve(this->values_.size()));
+  ASSERT_OK(builder.AppendValues(this->values_, this->validity_));
+  ASSERT_OK_AND_ASSIGN(auto array, builder.Finish());
+
+  const auto& carray = checked_cast<typename TypeParam::ArrayType&>(*array);
+
+  ASSERT_EQ(this->values_.size(), carray.length());
+  for (int64_t i = 0; i < carray.length(); ++i) {
+    auto res = carray[i];
+    if (this->validity_[i]) {
+      ASSERT_TRUE(res.has_value());
+      ASSERT_EQ(this->values_[i], res.value());
+    } else {
+      ASSERT_FALSE(res.has_value());
+      ASSERT_EQ(res, util::nullopt);
+    }
+  }
+}
+
 }  // namespace arrow
diff --git a/cpp/src/arrow/array/builder_binary.h b/cpp/src/arrow/array/builder_binary.h
index 6ca65113f1c..54a30aae1ed 100644
--- a/cpp/src/arrow/array/builder_binary.h
+++ b/cpp/src/arrow/array/builder_binary.h
@@ -280,7 +280,7 @@ class BaseBinaryBuilder : public ArrayBuilder {
     auto offsets = array.GetValues<offset_type>(1);
     auto data = array.GetValues<uint8_t>(2, 0);
     for (int64_t i = 0; i < length; i++) {
-      if (!bitmap || BitUtil::GetBit(bitmap, array.offset + offset + i)) {
+      if (!bitmap || bit_util::GetBit(bitmap, array.offset + offset + i)) {
         const offset_type start = offsets[offset + i];
         const offset_type end = offsets[offset + i + 1];
         ARROW_RETURN_NOT_OK(Append(data + start, end - start));
diff --git a/cpp/src/arrow/array/builder_nested.h b/cpp/src/arrow/array/builder_nested.h
index e53b758efa3..9e3a4458d8d 100644
--- a/cpp/src/arrow/array/builder_nested.h
+++ b/cpp/src/arrow/array/builder_nested.h
@@ -127,7 +127,7 @@ class BaseListBuilder : public ArrayBuilder {
     const offset_type* offsets = array.GetValues<offset_type>(1);
     const uint8_t* validity = array.MayHaveNulls() ? array.buffers[0]->data() : NULLPTR;
     for (int64_t row = offset; row < offset + length; row++) {
-      if (!validity || BitUtil::GetBit(validity, array.offset + row)) {
+      if (!validity || bit_util::GetBit(validity, array.offset + row)) {
         ARROW_RETURN_NOT_OK(Append());
         int64_t slot_length = offsets[row + 1] - offsets[row];
         ARROW_RETURN_NOT_OK(value_builder_->AppendArraySlice(*array.child_data[0],
@@ -297,7 +297,7 @@ class ARROW_EXPORT MapBuilder : public ArrayBuilder {
     const int32_t* offsets = array.GetValues<int32_t>(1);
     const uint8_t* validity = array.MayHaveNulls() ? array.buffers[0]->data() : NULLPTR;
     for (int64_t row = offset; row < offset + length; row++) {
-      if (!validity || BitUtil::GetBit(validity, array.offset + row)) {
+      if (!validity || bit_util::GetBit(validity, array.offset + row)) {
         ARROW_RETURN_NOT_OK(Append());
         const int64_t slot_length = offsets[row + 1] - offsets[row];
         ARROW_RETURN_NOT_OK(key_builder_->AppendArraySlice(
@@ -413,7 +413,7 @@ class ARROW_EXPORT FixedSizeListBuilder : public ArrayBuilder {
   Status AppendArraySlice(const ArrayData& array, int64_t offset, int64_t length) final {
     const uint8_t* validity = array.MayHaveNulls() ? array.buffers[0]->data() : NULLPTR;
     for (int64_t row = offset; row < offset + length; row++) {
-      if (!validity || BitUtil::GetBit(validity, array.offset + row)) {
+      if (!validity || bit_util::GetBit(validity, array.offset + row)) {
         ARROW_RETURN_NOT_OK(value_builder_->AppendArraySlice(
             *array.child_data[0], list_size_ * (array.offset + row), list_size_));
         ARROW_RETURN_NOT_OK(Append());
diff --git a/cpp/src/arrow/array/concatenate.cc b/cpp/src/arrow/array/concatenate.cc
index 54a75f06c90..0631fe6915d 100644
--- a/cpp/src/arrow/array/concatenate.cc
+++ b/cpp/src/arrow/array/concatenate.cc
@@ -83,7 +83,7 @@ Status ConcatenateBitmaps(const std::vector<Bitmap>& bitmaps, MemoryPool* pool,
   int64_t bitmap_offset = 0;
   for (auto bitmap : bitmaps) {
     if (bitmap.AllSet()) {
-      BitUtil::SetBitsTo(dst, bitmap_offset, bitmap.range.length, true);
+      bit_util::SetBitsTo(dst, bitmap_offset, bitmap.range.length, true);
     } else {
       internal::CopyBitmap(bitmap.data, bitmap.range.offset, bitmap.range.length, dst,
                            bitmap_offset);
diff --git a/cpp/src/arrow/array/concatenate_test.cc b/cpp/src/arrow/array/concatenate_test.cc
index 305910c247c..218a40ea066 100644
--- a/cpp/src/arrow/array/concatenate_test.cc
+++ b/cpp/src/arrow/array/concatenate_test.cc
@@ -77,7 +77,7 @@ class ConcatenateTest : public ::testing::Test {
   }
 
   void CheckTrailingBitsAreZeroed(const std::shared_ptr<Buffer>& bitmap, int64_t length) {
-    if (auto preceding_bits = BitUtil::kPrecedingBitmask[length % 8]) {
+    if (auto preceding_bits = bit_util::kPrecedingBitmask[length % 8]) {
       auto last_byte = bitmap->data()[length / 8];
       ASSERT_EQ(static_cast<uint8_t>(last_byte & preceding_bits), last_byte)
           << length << " " << int(preceding_bits);
diff --git a/cpp/src/arrow/array/diff.cc b/cpp/src/arrow/array/diff.cc
index 0a50de0f1f1..32a95450374 100644
--- a/cpp/src/arrow/array/diff.cc
+++ b/cpp/src/arrow/array/diff.cc
@@ -290,7 +290,7 @@ class QuadraticSpaceMyersDiff {
 
     for (int64_t i = edit_count_; i > 0; --i) {
       bool insert = insert_[index];
-      BitUtil::SetBitTo(insert_buf->mutable_data(), i, insert);
+      bit_util::SetBitTo(insert_buf->mutable_data(), i, insert);
 
       auto insertions_minus_deletions =
           (endpoint.base - base_begin_) - (endpoint.target - target_begin_);
@@ -308,7 +308,7 @@ class QuadraticSpaceMyersDiff {
 
       endpoint = previous;
     }
-    BitUtil::SetBitTo(insert_buf->mutable_data(), 0, false);
+    bit_util::SetBitTo(insert_buf->mutable_data(), 0, false);
     run_length[0] = endpoint.base - base_begin_;
 
     return StructArray::Make(
diff --git a/cpp/src/arrow/array/util.cc b/cpp/src/arrow/array/util.cc
index 2045b8f5c71..d5033e7ff0c 100644
--- a/cpp/src/arrow/array/util.cc
+++ b/cpp/src/arrow/array/util.cc
@@ -119,7 +119,7 @@ class ArrayDataEndianSwapper {
     // NOTE: data_->length not trusted (see warning above)
     int64_t length = in_buffer->size() / sizeof(T);
     for (int64_t i = 0; i < length; i++) {
-      out_data[i] = BitUtil::ByteSwap(in_data[i]);
+      out_data[i] = bit_util::ByteSwap(in_data[i]);
     }
     return std::move(out_buffer);
   }
@@ -158,12 +158,12 @@ class ArrayDataEndianSwapper {
       uint64_t tmp;
       auto idx = i * 2;
 #if ARROW_LITTLE_ENDIAN
-      tmp = BitUtil::FromBigEndian(data[idx]);
-      new_data[idx] = BitUtil::FromBigEndian(data[idx + 1]);
+      tmp = bit_util::FromBigEndian(data[idx]);
+      new_data[idx] = bit_util::FromBigEndian(data[idx + 1]);
       new_data[idx + 1] = tmp;
 #else
-      tmp = BitUtil::FromLittleEndian(data[idx]);
-      new_data[idx] = BitUtil::FromLittleEndian(data[idx + 1]);
+      tmp = bit_util::FromLittleEndian(data[idx]);
+      new_data[idx] = bit_util::FromLittleEndian(data[idx + 1]);
       new_data[idx + 1] = tmp;
 #endif
     }
@@ -181,18 +181,18 @@ class ArrayDataEndianSwapper {
       uint64_t tmp0, tmp1, tmp2;
       auto idx = i * 4;
 #if ARROW_LITTLE_ENDIAN
-      tmp0 = BitUtil::FromBigEndian(data[idx]);
-      tmp1 = BitUtil::FromBigEndian(data[idx + 1]);
-      tmp2 = BitUtil::FromBigEndian(data[idx + 2]);
-      new_data[idx] = BitUtil::FromBigEndian(data[idx + 3]);
+      tmp0 = bit_util::FromBigEndian(data[idx]);
+      tmp1 = bit_util::FromBigEndian(data[idx + 1]);
+      tmp2 = bit_util::FromBigEndian(data[idx + 2]);
+      new_data[idx] = bit_util::FromBigEndian(data[idx + 3]);
       new_data[idx + 1] = tmp2;
       new_data[idx + 2] = tmp1;
       new_data[idx + 3] = tmp0;
 #else
-      tmp0 = BitUtil::FromLittleEndian(data[idx]);
-      tmp1 = BitUtil::FromLittleEndian(data[idx + 1]);
-      tmp2 = BitUtil::FromLittleEndian(data[idx + 2]);
-      new_data[idx] = BitUtil::FromLittleEndian(data[idx + 3]);
+      tmp0 = bit_util::FromLittleEndian(data[idx]);
+      tmp1 = bit_util::FromLittleEndian(data[idx + 1]);
+      tmp2 = bit_util::FromLittleEndian(data[idx + 2]);
+      new_data[idx] = bit_util::FromLittleEndian(data[idx + 3]);
       new_data[idx + 1] = tmp2;
       new_data[idx + 2] = tmp1;
       new_data[idx + 3] = tmp0;
@@ -217,13 +217,13 @@ class ArrayDataEndianSwapper {
     for (int64_t i = 0; i < length; i++) {
       MonthDayNanos tmp = data[i];
 #if ARROW_LITTLE_ENDIAN
-      tmp.months = BitUtil::FromBigEndian(tmp.months);
-      tmp.days = BitUtil::FromBigEndian(tmp.days);
-      tmp.nanoseconds = BitUtil::FromBigEndian(tmp.nanoseconds);
+      tmp.months = bit_util::FromBigEndian(tmp.months);
+      tmp.days = bit_util::FromBigEndian(tmp.days);
+      tmp.nanoseconds = bit_util::FromBigEndian(tmp.nanoseconds);
 #else
-      tmp.months = BitUtil::FromLittleEndian(tmp.months);
-      tmp.days = BitUtil::FromLittleEndian(tmp.days);
-      tmp.nanoseconds = BitUtil::FromLittleEndian(tmp.nanoseconds);
+      tmp.months = bit_util::FromLittleEndian(tmp.months);
+      tmp.days = bit_util::FromLittleEndian(tmp.days);
+      tmp.nanoseconds = bit_util::FromLittleEndian(tmp.nanoseconds);
 #endif
       new_data[i] = tmp;
     }
@@ -324,7 +324,7 @@ class NullArrayFactory {
  public:
   struct GetBufferLength {
     GetBufferLength(const std::shared_ptr<DataType>& type, int64_t length)
-        : type_(*type), length_(length), buffer_length_(BitUtil::BytesForBits(length)) {}
+        : type_(*type), length_(length), buffer_length_(bit_util::BytesForBits(length)) {}
 
     Result<int64_t> Finish() && {
       RETURN_NOT_OK(VisitTypeInline(type_, this));
@@ -550,8 +550,8 @@ class RepeatedArrayFactory {
 
   Status Visit(const BooleanType&) {
     ARROW_ASSIGN_OR_RAISE(auto buffer, AllocateBitmap(length_, pool_));
-    BitUtil::SetBitsTo(buffer->mutable_data(), 0, length_,
-                       checked_cast<const BooleanScalar&>(scalar_).value);
+    bit_util::SetBitsTo(buffer->mutable_data(), 0, length_,
+                        checked_cast<const BooleanScalar&>(scalar_).value);
     out_ = std::make_shared<BooleanArray>(length_, buffer);
     return Status::OK();
   }
diff --git a/cpp/src/arrow/array/validate.cc b/cpp/src/arrow/array/validate.cc
index 52fcad5e7eb..7c4ab6d5248 100644
--- a/cpp/src/arrow/array/validate.cc
+++ b/cpp/src/arrow/array/validate.cc
@@ -385,7 +385,7 @@ struct ValidateArrayImpl {
       int64_t min_buffer_size = -1;
       switch (spec.kind) {
         case DataTypeLayout::BITMAP:
-          min_buffer_size = BitUtil::BytesForBits(length_plus_offset);
+          min_buffer_size = bit_util::BytesForBits(length_plus_offset);
           break;
         case DataTypeLayout::FIXED_WIDTH:
           if (MultiplyWithOverflow(length_plus_offset, spec.byte_width,
diff --git a/cpp/src/arrow/buffer.cc b/cpp/src/arrow/buffer.cc
index b1b2945d0f5..e663ff9dca8 100644
--- a/cpp/src/arrow/buffer.cc
+++ b/cpp/src/arrow/buffer.cc
@@ -171,7 +171,7 @@ MutableBuffer::MutableBuffer(const std::shared_ptr<Buffer>& parent, const int64_
 }
 
 Result<std::shared_ptr<Buffer>> AllocateBitmap(int64_t length, MemoryPool* pool) {
-  ARROW_ASSIGN_OR_RAISE(auto buf, AllocateBuffer(BitUtil::BytesForBits(length), pool));
+  ARROW_ASSIGN_OR_RAISE(auto buf, AllocateBuffer(bit_util::BytesForBits(length), pool));
   // Zero out any trailing bits
   if (buf->size() > 0) {
     buf->mutable_data()[buf->size() - 1] = 0;
@@ -180,7 +180,7 @@ Result<std::shared_ptr<Buffer>> AllocateBitmap(int64_t length, MemoryPool* pool)
 }
 
 Result<std::shared_ptr<Buffer>> AllocateEmptyBitmap(int64_t length, MemoryPool* pool) {
-  ARROW_ASSIGN_OR_RAISE(auto buf, AllocateBuffer(BitUtil::BytesForBits(length), pool));
+  ARROW_ASSIGN_OR_RAISE(auto buf, AllocateBuffer(bit_util::BytesForBits(length), pool));
   memset(buf->mutable_data(), 0, static_cast<size_t>(buf->size()));
   return std::move(buf);
 }
diff --git a/cpp/src/arrow/buffer_builder.h b/cpp/src/arrow/buffer_builder.h
index 7b02ad09a82..d92a01a16eb 100644
--- a/cpp/src/arrow/buffer_builder.h
+++ b/cpp/src/arrow/buffer_builder.h
@@ -333,7 +333,7 @@ class TypedBufferBuilder<bool> {
   }
 
   void UnsafeAppend(bool value) {
-    BitUtil::SetBitTo(mutable_data(), bit_length_, value);
+    bit_util::SetBitTo(mutable_data(), bit_length_, value);
     if (!value) {
       ++false_count_;
     }
@@ -361,7 +361,7 @@ class TypedBufferBuilder<bool> {
   }
 
   void UnsafeAppend(const int64_t num_copies, bool value) {
-    BitUtil::SetBitsTo(mutable_data(), bit_length_, num_copies, value);
+    bit_util::SetBitsTo(mutable_data(), bit_length_, num_copies, value);
     false_count_ += num_copies * !value;
     bit_length_ += num_copies;
   }
@@ -386,7 +386,7 @@ class TypedBufferBuilder<bool> {
   Status Resize(const int64_t new_capacity, bool shrink_to_fit = true) {
     const int64_t old_byte_capacity = bytes_builder_.capacity();
     ARROW_RETURN_NOT_OK(
-        bytes_builder_.Resize(BitUtil::BytesForBits(new_capacity), shrink_to_fit));
+        bytes_builder_.Resize(bit_util::BytesForBits(new_capacity), shrink_to_fit));
     // Resize() may have chosen a larger capacity (e.g. for padding),
     // so ask it again before calling memset().
     const int64_t new_byte_capacity = bytes_builder_.capacity();
@@ -414,7 +414,7 @@ class TypedBufferBuilder<bool> {
 
   Status Finish(std::shared_ptr<Buffer>* out, bool shrink_to_fit = true) {
     // set bytes_builder_.size_ == byte size of data
-    bytes_builder_.UnsafeAdvance(BitUtil::BytesForBits(bit_length_) -
+    bytes_builder_.UnsafeAdvance(bit_util::BytesForBits(bit_length_) -
                                  bytes_builder_.length());
     bit_length_ = false_count_ = 0;
     return bytes_builder_.Finish(out, shrink_to_fit);
@@ -433,7 +433,7 @@ class TypedBufferBuilder<bool> {
   /// only for memory allocation).
   Result<std::shared_ptr<Buffer>> FinishWithLength(int64_t final_length,
                                                    bool shrink_to_fit = true) {
-    const auto final_byte_length = BitUtil::BytesForBits(final_length);
+    const auto final_byte_length = bit_util::BytesForBits(final_length);
     bytes_builder_.UnsafeAdvance(final_byte_length - bytes_builder_.length());
     bit_length_ = false_count_ = 0;
     return bytes_builder_.FinishWithLength(final_byte_length, shrink_to_fit);
diff --git a/cpp/src/arrow/buffer_test.cc b/cpp/src/arrow/buffer_test.cc
index 4295d4ca692..a82c90be55c 100644
--- a/cpp/src/arrow/buffer_test.cc
+++ b/cpp/src/arrow/buffer_test.cc
@@ -797,12 +797,12 @@ TEST(TestBoolBufferBuilder, Basics) {
   ASSERT_OK(builder.Finish(&built));
   AssertIsCPUBuffer(*built);
 
-  ASSERT_EQ(BitUtil::GetBit(built->data(), 0), false);
+  ASSERT_EQ(bit_util::GetBit(built->data(), 0), false);
   for (int i = 0; i != nvalues; ++i) {
-    ASSERT_EQ(BitUtil::GetBit(built->data(), i + 1), static_cast<bool>(values[i]));
+    ASSERT_EQ(bit_util::GetBit(built->data(), i + 1), static_cast<bool>(values[i]));
   }
 
-  ASSERT_EQ(built->size(), BitUtil::BytesForBits(nvalues + 1));
+  ASSERT_EQ(built->size(), bit_util::BytesForBits(nvalues + 1));
 }
 
 TEST(TestBoolBufferBuilder, AppendCopies) {
@@ -819,10 +819,10 @@ TEST(TestBoolBufferBuilder, AppendCopies) {
   AssertIsCPUBuffer(*built);
 
   for (int i = 0; i != 13 + 17; ++i) {
-    EXPECT_EQ(BitUtil::GetBit(built->data(), i), i < 13) << "index = " << i;
+    EXPECT_EQ(bit_util::GetBit(built->data(), i), i < 13) << "index = " << i;
   }
 
-  ASSERT_EQ(built->size(), BitUtil::BytesForBits(13 + 17));
+  ASSERT_EQ(built->size(), bit_util::BytesForBits(13 + 17));
 }
 
 TEST(TestBoolBufferBuilder, Reserve) {
@@ -837,7 +837,7 @@ TEST(TestBoolBufferBuilder, Reserve) {
 
   ASSERT_OK_AND_ASSIGN(auto built, builder.Finish());
   AssertIsCPUBuffer(*built);
-  ASSERT_EQ(built->size(), BitUtil::BytesForBits(13 + 17));
+  ASSERT_EQ(built->size(), bit_util::BytesForBits(13 + 17));
 }
 
 template <typename T>
diff --git a/cpp/src/arrow/builder_benchmark.cc b/cpp/src/arrow/builder_benchmark.cc
index d0edb4b2d08..c131f813927 100644
--- a/cpp/src/arrow/builder_benchmark.cc
+++ b/cpp/src/arrow/builder_benchmark.cc
@@ -227,7 +227,7 @@ static std::vector<Integer> MakeSimilarIntDictFodder() {
     std::uniform_int_distribution<Integer> values_dist(0, kDistinctElements - 1);
     auto max_int = std::numeric_limits<Integer>::max();
     auto multiplier =
-        static_cast<Integer>(BitUtil::NextPower2(max_int / kDistinctElements / 2));
+        static_cast<Integer>(bit_util::NextPower2(max_int / kDistinctElements / 2));
     std::generate(values.begin(), values.end(),
                   [&]() { return multiplier * values_dist(gen); });
   }
diff --git a/cpp/src/arrow/c/bridge.cc b/cpp/src/arrow/c/bridge.cc
index e5bfad81027..f4137867313 100644
--- a/cpp/src/arrow/c/bridge.cc
+++ b/cpp/src/arrow/c/bridge.cc
@@ -1455,7 +1455,7 @@ struct ArrayImporter {
     RETURN_NOT_OK(CheckNumBuffers(2));
     RETURN_NOT_OK(AllocateArrayData());
     RETURN_NOT_OK(ImportNullBitmap());
-    if (BitUtil::IsMultipleOf8(type.bit_width())) {
+    if (bit_util::IsMultipleOf8(type.bit_width())) {
       RETURN_NOT_OK(ImportFixedSizeBuffer(1, type.bit_width() / 8));
     } else {
       DCHECK_EQ(type.bit_width(), 1);
@@ -1538,7 +1538,7 @@ struct ArrayImporter {
 
   Status ImportBitsBuffer(int32_t buffer_id) {
     // Compute visible size of buffer
-    int64_t buffer_size = BitUtil::BytesForBits(c_struct_->length + c_struct_->offset);
+    int64_t buffer_size = bit_util::BytesForBits(c_struct_->length + c_struct_->offset);
     return ImportBuffer(buffer_id, buffer_size);
   }
 
diff --git a/cpp/src/arrow/compare.cc b/cpp/src/arrow/compare.cc
index 4ecb00a3f08..d4b94e53838 100644
--- a/cpp/src/arrow/compare.cc
+++ b/cpp/src/arrow/compare.cc
@@ -202,8 +202,8 @@ class RangeDataEqualsImpl {
       if (length <= 8) {
         // Avoid the BitmapUInt64Reader overhead for very small runs
         for (int64_t j = i; j < i + length; ++j) {
-          if (BitUtil::GetBit(left_bits, left_start_idx_ + left_.offset + j) !=
-              BitUtil::GetBit(right_bits, right_start_idx_ + right_.offset + j)) {
+          if (bit_util::GetBit(left_bits, left_start_idx_ + left_.offset + j) !=
+              bit_util::GetBit(right_bits, right_start_idx_ + right_.offset + j)) {
             return false;
           }
         }
diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index d80398a24cd..24a5a1ee77e 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -173,6 +173,30 @@ struct EnumTraits<compute::RoundMode>
     return "<INVALID>";
   }
 };
+
+template <>
+struct EnumTraits<compute::Utf8NormalizeOptions::Form>
+    : BasicEnumTraits<compute::Utf8NormalizeOptions::Form,
+                      compute::Utf8NormalizeOptions::Form::NFC,
+                      compute::Utf8NormalizeOptions::Form::NFKC,
+                      compute::Utf8NormalizeOptions::Form::NFD,
+                      compute::Utf8NormalizeOptions::Form::NFKD> {
+  static std::string name() { return "Utf8NormalizeOptions::Form"; }
+  static std::string value_name(compute::Utf8NormalizeOptions::Form value) {
+    switch (value) {
+      case compute::Utf8NormalizeOptions::Form::NFC:
+        return "NFC";
+      case compute::Utf8NormalizeOptions::Form::NFKC:
+        return "NFKC";
+      case compute::Utf8NormalizeOptions::Form::NFD:
+        return "NFD";
+      case compute::Utf8NormalizeOptions::Form::NFKD:
+        return "NFKD";
+    }
+    return "<INVALID>";
+  }
+};
+
 }  // namespace internal
 
 namespace compute {
@@ -250,6 +274,8 @@ static auto kStructFieldOptionsType = GetFunctionOptionsType<StructFieldOptions>
     DataMember("indices", &StructFieldOptions::indices));
 static auto kTrimOptionsType = GetFunctionOptionsType<TrimOptions>(
     DataMember("characters", &TrimOptions::characters));
+static auto kUtf8NormalizeOptionsType = GetFunctionOptionsType<Utf8NormalizeOptions>(
+    DataMember("form", &Utf8NormalizeOptions::form));
 static auto kWeekOptionsType = GetFunctionOptionsType<WeekOptions>(
     DataMember("week_starts_monday", &WeekOptions::week_starts_monday),
     DataMember("count_from_zero", &WeekOptions::count_from_zero),
@@ -429,6 +455,10 @@ TrimOptions::TrimOptions(std::string characters)
 TrimOptions::TrimOptions() : TrimOptions("") {}
 constexpr char TrimOptions::kTypeName[];
 
+Utf8NormalizeOptions::Utf8NormalizeOptions(Form form)
+    : FunctionOptions(internal::kUtf8NormalizeOptionsType), form(form) {}
+constexpr char Utf8NormalizeOptions::kTypeName[];
+
 WeekOptions::WeekOptions(bool week_starts_monday, bool count_from_zero,
                          bool first_week_is_fully_in_year)
     : FunctionOptions(internal::kWeekOptionsType),
@@ -461,6 +491,7 @@ void RegisterScalarOptions(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunctionOptionsType(kStrptimeOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kStructFieldOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kTrimOptionsType));
+  DCHECK_OK(registry->AddFunctionOptionsType(kUtf8NormalizeOptionsType));
   DCHECK_OK(registry->AddFunctionOptionsType(kWeekOptionsType));
 }
 }  // namespace internal
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index d2234a6182d..6e1c1ac74e8 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -61,15 +61,16 @@ enum class RoundMode : int8_t {
   UP,
   /// Get the integral part without fractional digits (aka "trunc")
   TOWARDS_ZERO,
-  /// Round negative values with DOWN rule and positive values with UP rule
+  /// Round negative values with DOWN rule
+  /// and positive values with UP rule (aka "away from zero")
   TOWARDS_INFINITY,
-  /// Round ties with DOWN rule
+  /// Round ties with DOWN rule (also called "round half towards negative infinity")
   HALF_DOWN,
-  /// Round ties with UP rule
+  /// Round ties with UP rule (also called "round half towards positive infinity")
   HALF_UP,
-  /// Round ties with TOWARDS_ZERO rule
+  /// Round ties with TOWARDS_ZERO rule (also called "round half away from infinity")
   HALF_TOWARDS_ZERO,
-  /// Round ties with TOWARDS_INFINITY rule
+  /// Round ties with TOWARDS_INFINITY rule (also called "round half away from zero")
   HALF_TOWARDS_INFINITY,
   /// Round ties to nearest even integer
   HALF_TO_EVEN,
@@ -407,6 +408,18 @@ struct ARROW_EXPORT WeekOptions : public FunctionOptions {
   bool first_week_is_fully_in_year;
 };
 
+struct ARROW_EXPORT Utf8NormalizeOptions : public FunctionOptions {
+ public:
+  enum Form { NFC, NFKC, NFD, NFKD };
+
+  explicit Utf8NormalizeOptions(Form form = NFC);
+  static Utf8NormalizeOptions Defaults() { return Utf8NormalizeOptions(); }
+  constexpr static char const kTypeName[] = "Utf8NormalizeOptions";
+
+  /// The Unicode normalization form to apply
+  Form form;
+};
+
 /// @}
 
 /// \brief Get the absolute value of a value.
diff --git a/cpp/src/arrow/compute/exec.cc b/cpp/src/arrow/compute/exec.cc
index eda355d6eda..7128d2201f4 100644
--- a/cpp/src/arrow/compute/exec.cc
+++ b/cpp/src/arrow/compute/exec.cc
@@ -178,7 +178,7 @@ Result<std::shared_ptr<Buffer>> AllocateDataBuffer(KernelContext* ctx, int64_t l
   if (bit_width == 1) {
     return ctx->AllocateBitmap(length);
   } else {
-    int64_t buffer_size = BitUtil::BytesForBits(length * bit_width);
+    int64_t buffer_size = bit_util::BytesForBits(length * bit_width);
     return ctx->Allocate(buffer_size);
   }
 }
@@ -405,7 +405,7 @@ class NullPropagator {
     output_->null_count = output_->length;
 
     if (bitmap_preallocated_) {
-      BitUtil::SetBitsTo(bitmap_, output_->offset, output_->length, false);
+      bit_util::SetBitsTo(bitmap_, output_->offset, output_->length, false);
       return Status::OK();
     }
 
@@ -420,7 +420,7 @@ class NullPropagator {
     }
 
     RETURN_NOT_OK(EnsureAllocated());
-    BitUtil::SetBitsTo(bitmap_, output_->offset, output_->length, false);
+    bit_util::SetBitsTo(bitmap_, output_->offset, output_->length, false);
     return Status::OK();
   }
 
@@ -450,7 +450,7 @@ class NullPropagator {
       output_->buffers[0] = arr_bitmap;
     } else if (arr.offset % 8 == 0) {
       output_->buffers[0] =
-          SliceBuffer(arr_bitmap, arr.offset / 8, BitUtil::BytesForBits(arr.length));
+          SliceBuffer(arr_bitmap, arr.offset / 8, bit_util::BytesForBits(arr.length));
     } else {
       RETURN_NOT_OK(EnsureAllocated());
       CopyBitmap(arr_bitmap->data(), arr.offset, arr.length, bitmap_,
@@ -512,7 +512,7 @@ class NullPropagator {
       // No arrays with nulls case
       output_->null_count = 0;
       if (bitmap_preallocated_) {
-        BitUtil::SetBitsTo(bitmap_, output_->offset, output_->length, true);
+        bit_util::SetBitsTo(bitmap_, output_->offset, output_->length, true);
       }
       return Status::OK();
     }
diff --git a/cpp/src/arrow/compute/exec/aggregate_node.cc b/cpp/src/arrow/compute/exec/aggregate_node.cc
index ddf6f7934a7..59b2ff8b8af 100644
--- a/cpp/src/arrow/compute/exec/aggregate_node.cc
+++ b/cpp/src/arrow/compute/exec/aggregate_node.cc
@@ -441,7 +441,7 @@ class GroupByNode : public ExecNode {
     state->grouper.reset();
 
     if (output_counter_.SetTotal(
-            static_cast<int>(BitUtil::CeilDiv(out_data.length, output_batch_size())))) {
+            static_cast<int>(bit_util::CeilDiv(out_data.length, output_batch_size())))) {
       // this will be hit if out_data.length == 0
       finished_.MarkFinished();
     }
diff --git a/cpp/src/arrow/compute/exec/expression_test.cc b/cpp/src/arrow/compute/exec/expression_test.cc
index 94ca2074835..fa05ddf6422 100644
--- a/cpp/src/arrow/compute/exec/expression_test.cc
+++ b/cpp/src/arrow/compute/exec/expression_test.cc
@@ -1222,8 +1222,9 @@ TEST(Expression, SingleComparisonGuarantees) {
             all = false;
           }
         }
-        Simplify{filter}.WithGuarantee(guarantee).Expect(
-            all ? literal(true) : none ? literal(false) : filter);
+        Simplify{filter}.WithGuarantee(guarantee).Expect(all    ? literal(true)
+                                                         : none ? literal(false)
+                                                                : filter);
       }
     }
   }
diff --git a/cpp/src/arrow/compute/exec/hash_join.cc b/cpp/src/arrow/compute/exec/hash_join.cc
index 72226dda3a7..02f97dd6f86 100644
--- a/cpp/src/arrow/compute/exec/hash_join.cc
+++ b/cpp/src/arrow/compute/exec/hash_join.cc
@@ -191,8 +191,8 @@ class HashJoinBasicImpl : public HashJoinImpl {
       bool no_match = hash_table_empty_;
       for (int icol = 0; icol < num_cols; ++icol) {
         bool is_null = non_null_bit_vectors[icol] &&
-                       !BitUtil::GetBit(non_null_bit_vectors[icol],
-                                        non_null_bit_vector_offsets[icol] + irow);
+                       !bit_util::GetBit(non_null_bit_vectors[icol],
+                                         non_null_bit_vector_offsets[icol] + irow);
         if (key_cmp_[icol] == JoinKeyCmp::EQ && is_null) {
           no_match = true;
           break;
@@ -378,8 +378,8 @@ class HashJoinBasicImpl : public HashJoinImpl {
       bool passed = false;
       for (; static_cast<size_t>(irow) < num_rows && match_left[irow] == curr_left;
            irow++) {
-        bool is_valid = !validity || BitUtil::GetBit(validity, irow);
-        bool is_cmp_true = BitUtil::GetBit(comparisons, irow);
+        bool is_valid = !validity || bit_util::GetBit(validity, irow);
+        bool is_cmp_true = bit_util::GetBit(comparisons, irow);
         // We treat a null comparison result as false, like in SQL
         if (is_valid && is_cmp_true) {
           match_left[match_idx] = match_left[irow];
@@ -516,9 +516,9 @@ class HashJoinBasicImpl : public HashJoinImpl {
         ARROW_DCHECK(batch[i].is_scalar());
         if (!batch[i].scalar_as<arrow::internal::PrimitiveScalarBase>().is_valid) {
           if (nn_bit_vector_all_nulls->empty()) {
-            nn_bit_vector_all_nulls->resize(BitUtil::BytesForBits(batch.length));
+            nn_bit_vector_all_nulls->resize(bit_util::BytesForBits(batch.length));
             memset(nn_bit_vector_all_nulls->data(), 0,
-                   BitUtil::BytesForBits(batch.length));
+                   bit_util::BytesForBits(batch.length));
           }
           nn = nn_bit_vector_all_nulls->data();
         }
@@ -579,7 +579,7 @@ class HashJoinBasicImpl : public HashJoinImpl {
 
     for (auto i : local_state.match_right) {
       // Mark row in hash table as having a match
-      BitUtil::SetBit(local_state.has_match.data(), i);
+      bit_util::SetBit(local_state.has_match.data(), i);
     }
 
     RETURN_NOT_OK(ProbeBatch_OutputAll(thread_index, local_state.exec_batch_keys,
@@ -723,7 +723,7 @@ class HashJoinBasicImpl : public HashJoinImpl {
         join_type_ != JoinType::RIGHT_OUTER && join_type_ != JoinType::FULL_OUTER) {
       return 0;
     }
-    return BitUtil::CeilDiv(hash_table_keys_.num_rows(), hash_table_scan_unit_);
+    return bit_util::CeilDiv(hash_table_keys_.num_rows(), hash_table_scan_unit_);
   }
 
   Status ScanHashTable_exec_task(size_t thread_index, int64_t task_id) {
@@ -747,7 +747,7 @@ class HashJoinBasicImpl : public HashJoinImpl {
 
     bool match_search_value = (join_type_ == JoinType::RIGHT_SEMI);
     for (int32_t row_id = start_row_id; row_id < end_row_id; ++row_id) {
-      if (BitUtil::GetBit(has_match_.data(), row_id) == match_search_value) {
+      if (bit_util::GetBit(has_match_.data(), row_id) == match_search_value) {
         id_right.push_back(row_id);
       }
     }
@@ -821,8 +821,8 @@ class HashJoinBasicImpl : public HashJoinImpl {
     }
     if (!hash_table_empty_) {
       int32_t num_rows = hash_table_keys_.num_rows();
-      local_state->has_match.resize(BitUtil::BytesForBits(num_rows));
-      memset(local_state->has_match.data(), 0, BitUtil::BytesForBits(num_rows));
+      local_state->has_match.resize(bit_util::BytesForBits(num_rows));
+      memset(local_state->has_match.data(), 0, bit_util::BytesForBits(num_rows));
     }
     local_state->is_has_match_initialized = true;
   }
@@ -833,8 +833,8 @@ class HashJoinBasicImpl : public HashJoinImpl {
     }
 
     int32_t num_rows = hash_table_keys_.num_rows();
-    has_match_.resize(BitUtil::BytesForBits(num_rows));
-    memset(has_match_.data(), 0, BitUtil::BytesForBits(num_rows));
+    has_match_.resize(bit_util::BytesForBits(num_rows));
+    memset(has_match_.data(), 0, bit_util::BytesForBits(num_rows));
 
     for (size_t tid = 0; tid < local_states_.size(); ++tid) {
       if (!local_states_[tid].is_initialized) {
diff --git a/cpp/src/arrow/compute/exec/hash_join_dict.cc b/cpp/src/arrow/compute/exec/hash_join_dict.cc
index 195331a5976..b923433b493 100644
--- a/cpp/src/arrow/compute/exec/hash_join_dict.cc
+++ b/cpp/src/arrow/compute/exec/hash_join_dict.cc
@@ -71,13 +71,13 @@ Result<std::shared_ptr<ArrayData>> HashJoinDictUtil::IndexRemapUsingLUT(
   uint8_t* nns = result->buffers[0]->mutable_data();
   int32_t* ids = reinterpret_cast<int32_t*>(result->buffers[1]->mutable_data());
   for (int64_t i = 0; i < batch_length; ++i) {
-    bool is_null = !BitUtil::GetBit(nns, i);
+    bool is_null = !bit_util::GetBit(nns, i);
     if (is_null) {
       ids[i] = kNullId;
     } else {
       ARROW_DCHECK(ids[i] >= 0 && ids[i] < map_array->length);
-      if (!BitUtil::GetBit(map_non_nulls, ids[i])) {
-        BitUtil::ClearBit(nns, i);
+      if (!bit_util::GetBit(map_non_nulls, ids[i])) {
+        bit_util::ClearBit(nns, i);
         ids[i] = kNullId;
       } else {
         ids[i] = map[ids[i]];
@@ -102,7 +102,7 @@ static Result<std::shared_ptr<ArrayData>> ConvertImp(
   ARROW_ASSIGN_OR_RAISE(std::shared_ptr<Buffer> to_nn_buf,
                         AllocateBitmap(batch_length, ctx->memory_pool()));
   uint8_t* to_nn = to_nn_buf->mutable_data();
-  memset(to_nn, 0xff, BitUtil::BytesForBits(batch_length));
+  memset(to_nn, 0xff, bit_util::BytesForBits(batch_length));
 
   if (!is_scalar) {
     const ArrayData& arr = *input.array();
@@ -115,9 +115,9 @@ static Result<std::shared_ptr<ArrayData>> ConvertImp(
       ARROW_DCHECK(static_cast<FROM>(to[i]) == from[i]);
 
       bool is_null = (arr.buffers[0] != NULLPTR) &&
-                     !BitUtil::GetBit(arr.buffers[0]->data(), arr.offset + i);
+                     !bit_util::GetBit(arr.buffers[0]->data(), arr.offset + i);
       if (is_null) {
-        BitUtil::ClearBit(to_nn, i);
+        bit_util::ClearBit(to_nn, i);
       }
     }
 
@@ -138,11 +138,11 @@ static Result<std::shared_ptr<ArrayData>> ConvertImp(
         to[i] = to_value;
       }
 
-      memset(to_nn, 0xff, BitUtil::BytesForBits(batch_length));
+      memset(to_nn, 0xff, bit_util::BytesForBits(batch_length));
       return ArrayData::Make(to_type, batch_length,
                              {std::move(to_nn_buf), std::move(to_buf)});
     } else {
-      memset(to_nn, 0, BitUtil::BytesForBits(batch_length));
+      memset(to_nn, 0, bit_util::BytesForBits(batch_length));
       return ArrayData::Make(to_type, batch_length,
                              {std::move(to_nn_buf), std::move(to_buf)});
     }
@@ -245,7 +245,7 @@ Status HashJoinDictBuild::Init(ExecContext* ctx, std::shared_ptr<Array> dictiona
                         AllocateBuffer(length * sizeof(int32_t), ctx->memory_pool()));
   uint8_t* non_nulls = non_nulls_buf->mutable_data();
   int32_t* ids = reinterpret_cast<int32_t*>(ids_buf->mutable_data());
-  memset(non_nulls, 0xff, BitUtil::BytesForBits(length));
+  memset(non_nulls, 0xff, bit_util::BytesForBits(length));
 
   int32_t num_entries = 0;
   for (int64_t i = 0; i < length; ++i) {
@@ -257,7 +257,7 @@ Status HashJoinDictBuild::Init(ExecContext* ctx, std::shared_ptr<Array> dictiona
     //
     if (internal::KeyEncoder::IsNull(reinterpret_cast<const uint8_t*>(str.data()))) {
       ids[i] = HashJoinDictUtil::kNullId;
-      BitUtil::ClearBit(non_nulls, i);
+      bit_util::ClearBit(non_nulls, i);
       continue;
     }
 
@@ -307,7 +307,7 @@ Result<std::shared_ptr<ArrayData>> HashJoinDictBuild::RemapInputValues(
       AllocateBuffer(batch_length * sizeof(int32_t), ctx->memory_pool()));
   uint8_t* non_nulls = non_nulls_buf->mutable_data();
   int32_t* ids = reinterpret_cast<int32_t*>(ids_buf->mutable_data());
-  memset(non_nulls, 0xff, BitUtil::BytesForBits(batch_length));
+  memset(non_nulls, 0xff, bit_util::BytesForBits(batch_length));
 
   // Populate output buffers (for scalar only the first entry is populated)
   //
@@ -315,7 +315,7 @@ Result<std::shared_ptr<ArrayData>> HashJoinDictBuild::RemapInputValues(
     std::string str = encoder.encoded_row(static_cast<int32_t>(i));
     if (internal::KeyEncoder::IsNull(reinterpret_cast<const uint8_t*>(str.data()))) {
       // Map nulls to nulls
-      BitUtil::ClearBit(non_nulls, i);
+      bit_util::ClearBit(non_nulls, i);
       ids[i] = HashJoinDictUtil::kNullId;
     } else {
       auto iter = hash_table_.find(str);
@@ -330,8 +330,8 @@ Result<std::shared_ptr<ArrayData>> HashJoinDictBuild::RemapInputValues(
   // Generate array of repeated values for scalar input
   //
   if (is_scalar) {
-    if (!BitUtil::GetBit(non_nulls, 0)) {
-      memset(non_nulls, 0, BitUtil::BytesForBits(batch_length));
+    if (!bit_util::GetBit(non_nulls, 0)) {
+      memset(non_nulls, 0, bit_util::BytesForBits(batch_length));
     }
     for (int64_t i = 1; i < batch_length; ++i) {
       ids[i] = ids[0];
@@ -447,7 +447,7 @@ Result<std::shared_ptr<ArrayData>> HashJoinDictProbe::RemapInput(
           reinterpret_cast<int32_t*>(row_ids_arr->buffers[1]->mutable_data());
       const uint8_t* non_nulls = row_ids_arr->buffers[0]->data();
       for (int64_t i = 0; i < batch_length; ++i) {
-        if (!BitUtil::GetBit(non_nulls, i)) {
+        if (!bit_util::GetBit(non_nulls, i)) {
           row_ids[i] = internal::RowEncoder::kRowIdForNulls();
         }
       }
diff --git a/cpp/src/arrow/compute/exec/hash_join_node_test.cc b/cpp/src/arrow/compute/exec/hash_join_node_test.cc
index 481cd94d5c9..b8a18893da8 100644
--- a/cpp/src/arrow/compute/exec/hash_join_node_test.cc
+++ b/cpp/src/arrow/compute/exec/hash_join_node_test.cc
@@ -281,8 +281,10 @@ struct RandomDataTypeConstraints {
 
   void OnlyInt(int int_size, bool allow_nulls) {
     Default();
-    data_type_enabled_mask =
-        int_size == 8 ? kInt8 : int_size == 4 ? kInt4 : int_size == 2 ? kInt2 : kInt1;
+    data_type_enabled_mask = int_size == 8   ? kInt8
+                             : int_size == 4 ? kInt4
+                             : int_size == 2 ? kInt2
+                                             : kInt1;
     if (!allow_nulls) {
       max_null_probability = 0.0;
     }
@@ -459,7 +461,7 @@ void TakeUsingVector(ExecContext* ctx, const std::vector<std::shared_ptr<Array>>
         ASSERT_OK_AND_ASSIGN(std::shared_ptr<Buffer> null_buf,
                              AllocateBitmap(indices.size(), ctx->memory_pool()));
         uint8_t* non_nulls = null_buf->mutable_data();
-        memset(non_nulls, 0xFF, BitUtil::BytesForBits(indices.size()));
+        memset(non_nulls, 0xFF, bit_util::BytesForBits(indices.size()));
         if ((*result)[i]->data()->buffers.size() == 2) {
           (*result)[i] = MakeArray(
               ArrayData::Make((*result)[i]->type(), indices.size(),
@@ -477,7 +479,7 @@ void TakeUsingVector(ExecContext* ctx, const std::vector<std::shared_ptr<Array>>
       if (indices[i] < 0) {
         for (size_t col = 0; col < result->size(); ++col) {
           uint8_t* non_nulls = (*result)[col]->data()->buffers[0]->mutable_data();
-          BitUtil::ClearBit(non_nulls, i);
+          bit_util::ClearBit(non_nulls, i);
         }
       }
     }
@@ -546,7 +548,7 @@ std::vector<bool> NullInKey(const std::vector<JoinKeyCmp>& cmp,
       continue;
     }
     for (size_t j = 0; j < result.size(); ++j) {
-      if (!BitUtil::GetBit(nulls, j)) {
+      if (!bit_util::GetBit(nulls, j)) {
         result[j] = true;
       }
     }
@@ -1105,8 +1107,8 @@ TEST(HashJoin, Random) {
     std::shared_ptr<Table> output_rows_test;
     HashJoinWithExecPlan(rng, parallel, join_options, output_schema,
                          shuffled_input_arrays[0], shuffled_input_arrays[1],
-                         static_cast<int>(BitUtil::CeilDiv(num_rows_l, batch_size)),
-                         static_cast<int>(BitUtil::CeilDiv(num_rows_r, batch_size)),
+                         static_cast<int>(bit_util::CeilDiv(num_rows_l, batch_size)),
+                         static_cast<int>(bit_util::CeilDiv(num_rows_r, batch_size)),
                          &output_rows_test);
 
     // Compare results
@@ -1166,12 +1168,12 @@ void TestHashJoinDictionaryHelper(
     int expected_num_r_no_match,
     // Whether to swap two inputs to the hash join
     bool swap_sides) {
-  int64_t l_length = l_key.is_array()
-                         ? l_key.array()->length
-                         : l_payload.is_array() ? l_payload.array()->length : -1;
-  int64_t r_length = r_key.is_array()
-                         ? r_key.array()->length
-                         : r_payload.is_array() ? r_payload.array()->length : -1;
+  int64_t l_length = l_key.is_array()       ? l_key.array()->length
+                     : l_payload.is_array() ? l_payload.array()->length
+                                            : -1;
+  int64_t r_length = r_key.is_array()       ? r_key.array()->length
+                     : r_payload.is_array() ? r_payload.array()->length
+                                            : -1;
   ARROW_DCHECK(l_length >= 0 && r_length >= 0);
 
   constexpr int batch_multiplicity_for_parallel = 2;
diff --git a/cpp/src/arrow/compute/exec/key_compare.cc b/cpp/src/arrow/compute/exec/key_compare.cc
index 55b0e5e998b..368c63b8b92 100644
--- a/cpp/src/arrow/compute/exec/key_compare.cc
+++ b/cpp/src/arrow/compute/exec/key_compare.cc
@@ -57,7 +57,7 @@ void KeyCompare::NullUpdateColumnToRow(uint32_t id_col, uint32_t num_rows_to_com
       uint32_t irow_left = use_selection ? sel_left_maybe_null[i] : i;
       uint32_t irow_right = left_to_right_map[irow_left];
       int64_t bitid = irow_right * null_mask_num_bytes * 8 + id_col;
-      match_bytevector[i] &= (BitUtil::GetBit(null_masks, bitid) ? 0 : 0xff);
+      match_bytevector[i] &= (bit_util::GetBit(null_masks, bitid) ? 0 : 0xff);
     }
   } else if (!rows.has_any_nulls(ctx)) {
     // Remove rows from the result for which the column value on left side is null
@@ -66,7 +66,7 @@ void KeyCompare::NullUpdateColumnToRow(uint32_t id_col, uint32_t num_rows_to_com
     for (uint32_t i = num_processed; i < num_rows_to_compare; ++i) {
       uint32_t irow_left = use_selection ? sel_left_maybe_null[i] : i;
       match_bytevector[i] &=
-          BitUtil::GetBit(non_nulls, irow_left + col.bit_offset(0)) ? 0xff : 0;
+          bit_util::GetBit(non_nulls, irow_left + col.bit_offset(0)) ? 0xff : 0;
     }
   } else {
     const uint8_t* null_masks = rows.null_masks();
@@ -77,9 +77,9 @@ void KeyCompare::NullUpdateColumnToRow(uint32_t id_col, uint32_t num_rows_to_com
       uint32_t irow_left = use_selection ? sel_left_maybe_null[i] : i;
       uint32_t irow_right = left_to_right_map[irow_left];
       int64_t bitid_right = irow_right * null_mask_num_bytes * 8 + id_col;
-      int right_null = BitUtil::GetBit(null_masks, bitid_right) ? 0xff : 0;
+      int right_null = bit_util::GetBit(null_masks, bitid_right) ? 0xff : 0;
       int left_null =
-          BitUtil::GetBit(non_nulls, irow_left + col.bit_offset(0)) ? 0 : 0xff;
+          bit_util::GetBit(non_nulls, irow_left + col.bit_offset(0)) ? 0 : 0xff;
       match_bytevector[i] |= left_null & right_null;
       match_bytevector[i] &= ~(left_null ^ right_null);
     }
@@ -140,7 +140,8 @@ void KeyCompare::CompareBinaryColumnToRow(
         left_to_right_map, ctx, col, rows, match_bytevector,
         [bit_offset](const uint8_t* left_base, const uint8_t* right_base,
                      uint32_t irow_left, uint32_t offset_right) {
-          uint8_t left = BitUtil::GetBit(left_base, irow_left + bit_offset) ? 0xff : 0x00;
+          uint8_t left =
+              bit_util::GetBit(left_base, irow_left + bit_offset) ? 0xff : 0x00;
           uint8_t right = right_base[offset_right];
           return left == right ? 0xff : 0;
         });
@@ -200,7 +201,7 @@ void KeyCompare::CompareBinaryColumnToRow(
 
           // Non-zero length guarantees no underflow
           int32_t num_loops_less_one =
-              static_cast<int32_t>(BitUtil::CeilDiv(length, 8)) - 1;
+              static_cast<int32_t>(bit_util::CeilDiv(length, 8)) - 1;
 
           uint64_t tail_mask = ~0ULL >> (64 - 8 * (length - num_loops_less_one * 8));
 
@@ -271,7 +272,7 @@ void KeyCompare::CompareVarBinaryColumnToRow(
     if (length > 0) {
       int32_t j;
       // length can be zero
-      for (j = 0; j < static_cast<int32_t>(BitUtil::CeilDiv(length, 8)) - 1; ++j) {
+      for (j = 0; j < static_cast<int32_t>(bit_util::CeilDiv(length, 8)) - 1; ++j) {
         uint64_t key_left = util::SafeLoad(key_left_ptr + j);
         uint64_t key_right = key_right_ptr[j];
         result_or |= key_left ^ key_right;
@@ -296,7 +297,7 @@ void KeyCompare::AndByteVectors(KeyEncoder::KeyEncoderContext* ctx, uint32_t num
   }
 #endif
 
-  for (uint32_t i = num_processed / 8; i < BitUtil::CeilDiv(num_elements, 8); ++i) {
+  for (uint32_t i = num_processed / 8; i < bit_util::CeilDiv(num_elements, 8); ++i) {
     uint64_t* a = reinterpret_cast<uint64_t*>(bytevector_A);
     const uint64_t* b = reinterpret_cast<const uint64_t*>(bytevector_B);
     a[i] &= b[i];
@@ -403,19 +404,19 @@ void KeyCompare::CompareColumnsToRows(uint32_t num_rows_to_compare,
     }
   }
 
-  util::BitUtil::bytes_to_bits(ctx->hardware_flags, num_rows_to_compare,
-                               match_bytevector_A, match_bitvector);
+  util::bit_util::bytes_to_bits(ctx->hardware_flags, num_rows_to_compare,
+                                match_bytevector_A, match_bitvector);
   if (sel_left_maybe_null) {
     int out_num_rows_int;
-    util::BitUtil::bits_filter_indexes(0, ctx->hardware_flags, num_rows_to_compare,
-                                       match_bitvector, sel_left_maybe_null,
-                                       &out_num_rows_int, out_sel_left_maybe_same);
+    util::bit_util::bits_filter_indexes(0, ctx->hardware_flags, num_rows_to_compare,
+                                        match_bitvector, sel_left_maybe_null,
+                                        &out_num_rows_int, out_sel_left_maybe_same);
     *out_num_rows = out_num_rows_int;
   } else {
     int out_num_rows_int;
-    util::BitUtil::bits_to_indexes(0, ctx->hardware_flags, num_rows_to_compare,
-                                   match_bitvector, &out_num_rows_int,
-                                   out_sel_left_maybe_same);
+    util::bit_util::bits_to_indexes(0, ctx->hardware_flags, num_rows_to_compare,
+                                    match_bitvector, &out_num_rows_int,
+                                    out_sel_left_maybe_same);
     *out_num_rows = out_num_rows_int;
   }
 }
diff --git a/cpp/src/arrow/compute/exec/key_encode.cc b/cpp/src/arrow/compute/exec/key_encode.cc
index 8ab76cd27b3..d5e208bfb74 100644
--- a/cpp/src/arrow/compute/exec/key_encode.cc
+++ b/cpp/src/arrow/compute/exec/key_encode.cc
@@ -204,7 +204,7 @@ Status KeyEncoder::KeyRowArray::AppendSelectionFrom(const KeyRowArray& from,
       uint32_t length = from_offsets[row_id + 1] - from_offsets[row_id];
       auto src64 = reinterpret_cast<const uint64_t*>(src + from_offsets[row_id]);
       auto dst64 = reinterpret_cast<uint64_t*>(dst);
-      for (uint32_t j = 0; j < BitUtil::CeilDiv(length, 8); ++j) {
+      for (uint32_t j = 0; j < bit_util::CeilDiv(length, 8); ++j) {
         dst64[j] = src64[j];
       }
       dst += length;
@@ -218,7 +218,7 @@ Status KeyEncoder::KeyRowArray::AppendSelectionFrom(const KeyRowArray& from,
       uint32_t length = metadata_.fixed_length;
       auto src64 = reinterpret_cast<const uint64_t*>(src + length * row_id);
       auto dst64 = reinterpret_cast<uint64_t*>(dst);
-      for (uint32_t j = 0; j < BitUtil::CeilDiv(length, 8); ++j) {
+      for (uint32_t j = 0; j < bit_util::CeilDiv(length, 8); ++j) {
         dst64[j] = src64[j];
       }
       dst += length;
@@ -263,7 +263,7 @@ bool KeyEncoder::KeyRowArray::has_any_nulls(const KeyEncoderContext* ctx) const
   }
   if (num_rows_for_has_any_nulls_ < num_rows_) {
     auto size_per_row = metadata().null_masks_bytes_per_row;
-    has_any_nulls_ = !util::BitUtil::are_all_bytes_zero(
+    has_any_nulls_ = !util::bit_util::are_all_bytes_zero(
         ctx->hardware_flags, null_masks() + size_per_row * num_rows_for_has_any_nulls_,
         static_cast<uint32_t>(size_per_row * (num_rows_ - num_rows_for_has_any_nulls_)));
     num_rows_for_has_any_nulls_ = num_rows_;
@@ -374,7 +374,7 @@ void KeyEncoder::TransformBoolean::PostDecode(const KeyColumnArray& input,
   DCHECK(input.data(buffer_index) != nullptr);
   DCHECK(output->mutable_data(buffer_index) != nullptr);
 
-  util::BitUtil::bytes_to_bits(
+  util::bit_util::bytes_to_bits(
       ctx->hardware_flags, static_cast<int>(input.length()), input.data(buffer_index),
       output->mutable_data(buffer_index), output->bit_offset(buffer_index));
 }
@@ -543,7 +543,7 @@ void KeyEncoder::EncoderBinary::DecodeImp(uint32_t start_row, uint32_t num_rows,
   DecodeHelper<is_row_fixed_length>(
       start_row, num_rows, offset_within_row, &rows, nullptr, col, col,
       [](uint8_t* dst, const uint8_t* src, int64_t length) {
-        for (uint32_t istripe = 0; istripe < BitUtil::CeilDiv(length, 8); ++istripe) {
+        for (uint32_t istripe = 0; istripe < bit_util::CeilDiv(length, 8); ++istripe) {
           auto dst64 = reinterpret_cast<uint64_t*>(dst);
           auto src64 = reinterpret_cast<const uint64_t*>(src);
           util::SafeStore(dst64 + istripe, src64[istripe]);
@@ -572,10 +572,14 @@ void KeyEncoder::EncoderBinaryPair::Decode(uint32_t start_row, uint32_t num_rows
 
   uint32_t col_width1 = col_prep[0].metadata().fixed_length;
   uint32_t col_width2 = col_prep[1].metadata().fixed_length;
-  int log_col_width1 =
-      col_width1 == 8 ? 3 : col_width1 == 4 ? 2 : col_width1 == 2 ? 1 : 0;
-  int log_col_width2 =
-      col_width2 == 8 ? 3 : col_width2 == 4 ? 2 : col_width2 == 2 ? 1 : 0;
+  int log_col_width1 = col_width1 == 8   ? 3
+                       : col_width1 == 4 ? 2
+                       : col_width1 == 2 ? 1
+                                         : 0;
+  int log_col_width2 = col_width2 == 8   ? 3
+                       : col_width2 == 4 ? 2
+                       : col_width2 == 2 ? 1
+                                         : 0;
 
   bool is_row_fixed_length = rows.metadata().is_fixed_length;
 
@@ -746,7 +750,7 @@ void KeyEncoder::EncoderVarBinary::DecodeImp(uint32_t start_row, uint32_t num_ro
   DecodeHelper<first_varbinary_col>(
       start_row, num_rows, varbinary_col_id, &rows, nullptr, col, col,
       [](uint8_t* dst, const uint8_t* src, int64_t length) {
-        for (uint32_t istripe = 0; istripe < BitUtil::CeilDiv(length, 8); ++istripe) {
+        for (uint32_t istripe = 0; istripe < bit_util::CeilDiv(length, 8); ++istripe) {
           auto dst64 = reinterpret_cast<uint64_t*>(dst);
           auto src64 = reinterpret_cast<const uint64_t*>(src);
           util::SafeStore(dst64 + istripe, src64[istripe]);
@@ -774,14 +778,14 @@ void KeyEncoder::EncoderNulls::Decode(uint32_t start_row, uint32_t num_rows,
     non_nulls[0] |= 0xff << (bit_offset);
     if (bit_offset + num_rows > 8) {
       int bits_in_first_byte = 8 - bit_offset;
-      memset(non_nulls + 1, 0xff, BitUtil::BytesForBits(num_rows - bits_in_first_byte));
+      memset(non_nulls + 1, 0xff, bit_util::BytesForBits(num_rows - bits_in_first_byte));
     }
     for (uint32_t row = 0; row < num_rows; ++row) {
       uint32_t null_masks_bit_id =
           (start_row + row) * null_masks_bytes_per_row * 8 + static_cast<uint32_t>(col);
-      bool is_set = BitUtil::GetBit(null_masks, null_masks_bit_id);
+      bool is_set = bit_util::GetBit(null_masks, null_masks_bit_id);
       if (is_set) {
-        BitUtil::ClearBit(non_nulls, bit_offset + row);
+        bit_util::ClearBit(non_nulls, bit_offset + row);
       }
     }
   }
@@ -1055,7 +1059,7 @@ void KeyEncoder::EncoderBinary::EncodeSelectedImp(
       const uint8_t* non_null_bits = col.data(0);
       uint8_t* dst = rows->mutable_data(1) + offset_within_row;
       for (uint32_t i = 0; i < num_selected; ++i) {
-        bool is_null = !BitUtil::GetBit(non_null_bits, selection[i] + col.bit_offset(0));
+        bool is_null = !bit_util::GetBit(non_null_bits, selection[i] + col.bit_offset(0));
         if (is_null) {
           set_null_fn(dst);
         }
@@ -1074,7 +1078,7 @@ void KeyEncoder::EncoderBinary::EncodeSelectedImp(
       uint8_t* dst = rows->mutable_data(2) + offset_within_row;
       const uint32_t* offsets = rows->offsets();
       for (uint32_t i = 0; i < num_selected; ++i) {
-        bool is_null = !BitUtil::GetBit(non_null_bits, selection[i] + col.bit_offset(0));
+        bool is_null = !bit_util::GetBit(non_null_bits, selection[i] + col.bit_offset(0));
         if (is_null) {
           set_null_fn(dst + offsets[i]);
         }
@@ -1094,7 +1098,7 @@ void KeyEncoder::EncoderBinary::EncodeSelected(uint32_t offset_within_row,
     EncodeSelectedImp(
         offset_within_row, rows, col, num_selected, selection,
         [bit_offset](uint8_t* dst, const uint8_t* src_base, uint16_t irow) {
-          *dst = BitUtil::GetBit(src_base, irow + bit_offset) ? 0xff : 0x00;
+          *dst = bit_util::GetBit(src_base, irow + bit_offset) ? 0xff : 0x00;
         },
         [](uint8_t* dst) { *dst = 0xae; });
   } else if (col_width == 1) {
@@ -1168,7 +1172,8 @@ void KeyEncoder::EncoderOffsets::GetRowOffsetsSelected(
         const uint32_t* col_offsets = cols[icol].offsets();
         for (uint32_t i = 0; i < num_selected; ++i) {
           uint32_t irow = selection[i];
-          bool is_null = !BitUtil::GetBit(non_null_bits, irow + cols[icol].bit_offset(0));
+          bool is_null =
+              !bit_util::GetBit(non_null_bits, irow + cols[icol].bit_offset(0));
           if (is_null) {
             uint32_t length = col_offsets[irow + 1] - col_offsets[irow];
             row_offsets[i] -= length;
@@ -1205,8 +1210,8 @@ void KeyEncoder::EncoderOffsets::EncodeSelectedImp(
     uint32_t length = col_offsets[irow + 1] - col_offsets[irow];
     if (has_nulls) {
       uint32_t null_multiplier =
-          BitUtil::GetBit(col_non_null_bits, irow + cols[ivarbinary].bit_offset(0)) ? 1
-                                                                                    : 0;
+          bit_util::GetBit(col_non_null_bits, irow + cols[ivarbinary].bit_offset(0)) ? 1
+                                                                                     : 0;
       length *= null_multiplier;
     }
     uint32_t* row = reinterpret_cast<uint32_t*>(row_base + row_offsets[i]);
@@ -1289,9 +1294,9 @@ void KeyEncoder::EncoderNulls::EncodeSelected(KeyRowArray* rows,
     if (non_null_bits) {
       for (uint32_t i = 0; i < num_selected; ++i) {
         uint32_t irow = selection[i];
-        bool is_null = !BitUtil::GetBit(non_null_bits, irow + cols[icol].bit_offset(0));
+        bool is_null = !bit_util::GetBit(non_null_bits, irow + cols[icol].bit_offset(0));
         if (is_null) {
-          BitUtil::SetBit(null_masks, i * null_mask_num_bytes * 8 + icol);
+          bit_util::SetBit(null_masks, i * null_mask_num_bytes * 8 + icol);
         }
       }
     }
diff --git a/cpp/src/arrow/compute/exec/key_hash.cc b/cpp/src/arrow/compute/exec/key_hash.cc
index 76c8ed1ef30..12065cdd3cb 100644
--- a/cpp/src/arrow/compute/exec/key_hash.cc
+++ b/cpp/src/arrow/compute/exec/key_hash.cc
@@ -280,9 +280,9 @@ void Hashing::HashMultiColumn(const std::vector<KeyEncoder::KeyColumnArray>& col
     if (cols[icol].metadata().is_fixed_length) {
       uint32_t col_width = cols[icol].metadata().fixed_length;
       if (col_width == 0) {
-        util::BitUtil::bits_to_bytes(ctx->hardware_flags, num_rows, cols[icol].data(1),
-                                     byte_temp_buf.mutable_data(),
-                                     cols[icol].bit_offset(1));
+        util::bit_util::bits_to_bytes(ctx->hardware_flags, num_rows, cols[icol].data(1),
+                                      byte_temp_buf.mutable_data(),
+                                      cols[icol].bit_offset(1));
       }
       Hashing::hash_fixed(
           ctx->hardware_flags, num_rows, col_width == 0 ? 1 : col_width,
@@ -299,9 +299,9 @@ void Hashing::HashMultiColumn(const std::vector<KeyEncoder::KeyColumnArray>& col
     if (cols[icol].data(0)) {
       uint32_t* dst_hash = is_first ? out_hash : hash_temp_buf.mutable_data();
       int num_nulls;
-      util::BitUtil::bits_to_indexes(0, ctx->hardware_flags, num_rows, cols[icol].data(0),
-                                     &num_nulls, hash_null_index_buf.mutable_data(),
-                                     cols[icol].bit_offset(0));
+      util::bit_util::bits_to_indexes(
+          0, ctx->hardware_flags, num_rows, cols[icol].data(0), &num_nulls,
+          hash_null_index_buf.mutable_data(), cols[icol].bit_offset(0));
       for (int i = 0; i < num_nulls; ++i) {
         uint16_t row_id = hash_null_index_buf.mutable_data()[i];
         dst_hash[row_id] = 0;
diff --git a/cpp/src/arrow/compute/exec/key_map.cc b/cpp/src/arrow/compute/exec/key_map.cc
index bff352e0155..fe5ed98bb3e 100644
--- a/cpp/src/arrow/compute/exec/key_map.cc
+++ b/cpp/src/arrow/compute/exec/key_map.cc
@@ -28,7 +28,7 @@
 
 namespace arrow {
 
-using BitUtil::CountLeadingZeros;
+using bit_util::CountLeadingZeros;
 
 namespace compute {
 
@@ -198,7 +198,7 @@ void SwissTable::init_slot_ids(const int num_keys, const uint16_t* selection,
   if (log_blocks_ == 0) {
     for (int i = 0; i < num_keys; ++i) {
       uint16_t id = selection[i];
-      uint32_t match = ::arrow::BitUtil::GetBit(match_bitvector, id) ? 1 : 0;
+      uint32_t match = ::arrow::bit_util::GetBit(match_bitvector, id) ? 1 : 0;
       uint32_t slot_id = local_slots[id] + match;
       out_slot_ids[id] = slot_id;
     }
@@ -207,7 +207,7 @@ void SwissTable::init_slot_ids(const int num_keys, const uint16_t* selection,
       uint16_t id = selection[i];
       uint32_t hash = hashes[id];
       uint32_t iblock = (hash >> (bits_hash_ - log_blocks_));
-      uint32_t match = ::arrow::BitUtil::GetBit(match_bitvector, id) ? 1 : 0;
+      uint32_t match = ::arrow::bit_util::GetBit(match_bitvector, id) ? 1 : 0;
       uint32_t slot_id = iblock * 8 + local_slots[id] + match;
       out_slot_ids[id] = slot_id;
     }
@@ -371,9 +371,9 @@ void SwissTable::run_comparisons(const int num_keys,
       equal_impl_(num_keys, nullptr, groupids, &out_num, out_not_equal_selection);
       *out_num_not_equal = static_cast<int>(out_num);
     } else {
-      util::BitUtil::bits_to_indexes(1, hardware_flags_, num_keys,
-                                     optional_selection_bitvector, out_num_not_equal,
-                                     out_not_equal_selection);
+      util::bit_util::bits_to_indexes(1, hardware_flags_, num_keys,
+                                      optional_selection_bitvector, out_num_not_equal,
+                                      out_not_equal_selection);
       uint32_t out_num;
       equal_impl_(*out_num_not_equal, out_not_equal_selection, groupids, &out_num,
                   out_not_equal_selection);
@@ -500,8 +500,8 @@ void SwissTable::find(const int num_keys, const uint32_t* hashes,
     run_comparisons(num_keys, nullptr, inout_match_bitvector, out_group_ids, &num_ids,
                     ids);
   } else {
-    util::BitUtil::bits_to_indexes(1, hardware_flags_, num_keys, inout_match_bitvector,
-                                   &num_ids, ids);
+    util::bit_util::bits_to_indexes(1, hardware_flags_, num_keys, inout_match_bitvector,
+                                    &num_ids, ids);
     extract_group_ids(num_ids, ids, hashes, local_slots, out_group_ids);
     run_comparisons(num_ids, ids, nullptr, out_group_ids, &num_ids, ids);
   }
@@ -525,7 +525,7 @@ void SwissTable::find(const int num_keys, const uint32_t* hashes,
       slot_ids[id] = next_slot_id;
       // If next match was not found then clear match bit in a bit vector
       if (!match_found) {
-        ::arrow::BitUtil::ClearBit(inout_match_bitvector, id);
+        ::arrow::bit_util::ClearBit(inout_match_bitvector, id);
       } else {
         ids[num_ids++] = id;
       }
@@ -580,7 +580,7 @@ Status SwissTable::map_new_keys_helper(const uint32_t* hashes,
       //
       out_group_ids[id] = num_inserted_ + num_inserted_new;
       insert_into_empty_slot(inout_next_slot_ids[id], hashes[id], out_group_ids[id]);
-      ::arrow::BitUtil::ClearBit(match_bitvector, num_processed);
+      ::arrow::bit_util::ClearBit(match_bitvector, num_processed);
       ++num_inserted_new;
 
       // We need to break processing and have the caller of this function
@@ -600,15 +600,15 @@ Status SwissTable::map_new_keys_helper(const uint32_t* hashes,
 
   // Copy keys for newly inserted rows using callback
   //
-  util::BitUtil::bits_filter_indexes(0, hardware_flags_, num_processed, match_bitvector,
-                                     inout_selection, &num_temp_ids, temp_ids);
+  util::bit_util::bits_filter_indexes(0, hardware_flags_, num_processed, match_bitvector,
+                                      inout_selection, &num_temp_ids, temp_ids);
   ARROW_DCHECK(static_cast<int>(num_inserted_new) == num_temp_ids);
   RETURN_NOT_OK(append_impl_(num_inserted_new, temp_ids));
   num_inserted_ += num_inserted_new;
 
   // Evaluate comparisons and append ids of rows that failed it to the non-match set.
-  util::BitUtil::bits_filter_indexes(1, hardware_flags_, num_processed, match_bitvector,
-                                     inout_selection, &num_temp_ids, temp_ids);
+  util::bit_util::bits_filter_indexes(1, hardware_flags_, num_processed, match_bitvector,
+                                      inout_selection, &num_temp_ids, temp_ids);
   run_comparisons(num_temp_ids, temp_ids, nullptr, out_group_ids, &num_temp_ids,
                   temp_ids);
 
diff --git a/cpp/src/arrow/compute/exec/key_map.h b/cpp/src/arrow/compute/exec/key_map.h
index cf539f4a99b..12c1e393c4a 100644
--- a/cpp/src/arrow/compute/exec/key_map.h
+++ b/cpp/src/arrow/compute/exec/key_map.h
@@ -153,8 +153,10 @@ class SwissTable {
 
   static int num_groupid_bits_from_log_blocks(int log_blocks) {
     int required_bits = log_blocks + 3;
-    return required_bits <= 8 ? 8
-                              : required_bits <= 16 ? 16 : required_bits <= 32 ? 32 : 64;
+    return required_bits <= 8    ? 8
+           : required_bits <= 16 ? 16
+           : required_bits <= 32 ? 32
+                                 : 64;
   }
 
   // Use 32-bit hash for now
diff --git a/cpp/src/arrow/compute/exec/util.cc b/cpp/src/arrow/compute/exec/util.cc
index 64060d44564..6e26927e40c 100644
--- a/cpp/src/arrow/compute/exec/util.cc
+++ b/cpp/src/arrow/compute/exec/util.cc
@@ -25,12 +25,12 @@
 
 namespace arrow {
 
-using BitUtil::CountTrailingZeros;
+using bit_util::CountTrailingZeros;
 
 namespace util {
 
-inline void BitUtil::bits_to_indexes_helper(uint64_t word, uint16_t base_index,
-                                            int* num_indexes, uint16_t* indexes) {
+inline void bit_util::bits_to_indexes_helper(uint64_t word, uint16_t base_index,
+                                             int* num_indexes, uint16_t* indexes) {
   int n = *num_indexes;
   while (word) {
     indexes[n++] = base_index + static_cast<uint16_t>(CountTrailingZeros(word));
@@ -39,9 +39,9 @@ inline void BitUtil::bits_to_indexes_helper(uint64_t word, uint16_t base_index,
   *num_indexes = n;
 }
 
-inline void BitUtil::bits_filter_indexes_helper(uint64_t word,
-                                                const uint16_t* input_indexes,
-                                                int* num_indexes, uint16_t* indexes) {
+inline void bit_util::bits_filter_indexes_helper(uint64_t word,
+                                                 const uint16_t* input_indexes,
+                                                 int* num_indexes, uint16_t* indexes) {
   int n = *num_indexes;
   while (word) {
     indexes[n++] = input_indexes[CountTrailingZeros(word)];
@@ -51,10 +51,10 @@ inline void BitUtil::bits_filter_indexes_helper(uint64_t word,
 }
 
 template <int bit_to_search, bool filter_input_indexes>
-void BitUtil::bits_to_indexes_internal(int64_t hardware_flags, const int num_bits,
-                                       const uint8_t* bits, const uint16_t* input_indexes,
-                                       int* num_indexes, uint16_t* indexes,
-                                       uint16_t base_index) {
+void bit_util::bits_to_indexes_internal(int64_t hardware_flags, const int num_bits,
+                                        const uint8_t* bits,
+                                        const uint16_t* input_indexes, int* num_indexes,
+                                        uint16_t* indexes, uint16_t base_index) {
   // 64 bits at a time
   constexpr int unroll = 64;
   int tail = num_bits % unroll;
@@ -101,9 +101,9 @@ void BitUtil::bits_to_indexes_internal(int64_t hardware_flags, const int num_bit
   }
 }
 
-void BitUtil::bits_to_indexes(int bit_to_search, int64_t hardware_flags, int num_bits,
-                              const uint8_t* bits, int* num_indexes, uint16_t* indexes,
-                              int bit_offset) {
+void bit_util::bits_to_indexes(int bit_to_search, int64_t hardware_flags, int num_bits,
+                               const uint8_t* bits, int* num_indexes, uint16_t* indexes,
+                               int bit_offset) {
   bits += bit_offset / 8;
   bit_offset %= 8;
   *num_indexes = 0;
@@ -135,10 +135,10 @@ void BitUtil::bits_to_indexes(int bit_to_search, int64_t hardware_flags, int num
   *num_indexes += num_indexes_new;
 }
 
-void BitUtil::bits_filter_indexes(int bit_to_search, int64_t hardware_flags,
-                                  const int num_bits, const uint8_t* bits,
-                                  const uint16_t* input_indexes, int* num_indexes,
-                                  uint16_t* indexes, int bit_offset) {
+void bit_util::bits_filter_indexes(int bit_to_search, int64_t hardware_flags,
+                                   const int num_bits, const uint8_t* bits,
+                                   const uint16_t* input_indexes, int* num_indexes,
+                                   uint16_t* indexes, int bit_offset) {
   bits += bit_offset / 8;
   bit_offset %= 8;
   if (bit_offset != 0) {
@@ -169,10 +169,10 @@ void BitUtil::bits_filter_indexes(int bit_to_search, int64_t hardware_flags,
   }
 }
 
-void BitUtil::bits_split_indexes(int64_t hardware_flags, const int num_bits,
-                                 const uint8_t* bits, int* num_indexes_bit0,
-                                 uint16_t* indexes_bit0, uint16_t* indexes_bit1,
-                                 int bit_offset) {
+void bit_util::bits_split_indexes(int64_t hardware_flags, const int num_bits,
+                                  const uint8_t* bits, int* num_indexes_bit0,
+                                  uint16_t* indexes_bit0, uint16_t* indexes_bit1,
+                                  int bit_offset) {
   bits_to_indexes(0, hardware_flags, num_bits, bits, num_indexes_bit0, indexes_bit0,
                   bit_offset);
   int num_indexes_bit1;
@@ -180,8 +180,8 @@ void BitUtil::bits_split_indexes(int64_t hardware_flags, const int num_bits,
                   bit_offset);
 }
 
-void BitUtil::bits_to_bytes(int64_t hardware_flags, const int num_bits,
-                            const uint8_t* bits, uint8_t* bytes, int bit_offset) {
+void bit_util::bits_to_bytes(int64_t hardware_flags, const int num_bits,
+                             const uint8_t* bits, uint8_t* bytes, int bit_offset) {
   bits += bit_offset / 8;
   bit_offset %= 8;
   if (bit_offset != 0) {
@@ -221,8 +221,8 @@ void BitUtil::bits_to_bytes(int64_t hardware_flags, const int num_bits,
   }
 }
 
-void BitUtil::bytes_to_bits(int64_t hardware_flags, const int num_bits,
-                            const uint8_t* bytes, uint8_t* bits, int bit_offset) {
+void bit_util::bytes_to_bits(int64_t hardware_flags, const int num_bits,
+                             const uint8_t* bytes, uint8_t* bits, int bit_offset) {
   bits += bit_offset / 8;
   bit_offset %= 8;
   if (bit_offset != 0) {
@@ -260,8 +260,8 @@ void BitUtil::bytes_to_bits(int64_t hardware_flags, const int num_bits,
   }
 }
 
-bool BitUtil::are_all_bytes_zero(int64_t hardware_flags, const uint8_t* bytes,
-                                 uint32_t num_bytes) {
+bool bit_util::are_all_bytes_zero(int64_t hardware_flags, const uint8_t* bytes,
+                                  uint32_t num_bytes) {
 #if defined(ARROW_HAVE_AVX2)
   if (hardware_flags & arrow::internal::CpuInfo::AVX2) {
     return are_all_bytes_zero_avx2(bytes, num_bytes);
diff --git a/cpp/src/arrow/compute/exec/util.h b/cpp/src/arrow/compute/exec/util.h
index 800c6f0e91a..3efb3115830 100644
--- a/cpp/src/arrow/compute/exec/util.h
+++ b/cpp/src/arrow/compute/exec/util.h
@@ -89,7 +89,7 @@ class TempVectorStack {
     // using SIMD when number of vector elements is not divisible
     // by the number of SIMD lanes.
     //
-    return ::arrow::BitUtil::RoundUp(num_bytes, sizeof(int64_t)) + kPadding;
+    return ::arrow::bit_util::RoundUp(num_bytes, sizeof(int64_t)) + kPadding;
   }
   void alloc(uint32_t num_bytes, uint8_t** data, int* id) {
     int64_t old_top = top_;
@@ -144,7 +144,7 @@ class TempVectorHolder {
   uint32_t num_elements_;
 };
 
-class BitUtil {
+class bit_util {
  public:
   static void bits_to_indexes(int bit_to_search, int64_t hardware_flags,
                               const int num_bits, const uint8_t* bits, int* num_indexes,
diff --git a/cpp/src/arrow/compute/exec/util_avx2.cc b/cpp/src/arrow/compute/exec/util_avx2.cc
index bdc0e41f576..2357bc936a2 100644
--- a/cpp/src/arrow/compute/exec/util_avx2.cc
+++ b/cpp/src/arrow/compute/exec/util_avx2.cc
@@ -25,9 +25,9 @@ namespace util {
 
 #if defined(ARROW_HAVE_AVX2)
 
-void BitUtil::bits_to_indexes_avx2(int bit_to_search, const int num_bits,
-                                   const uint8_t* bits, int* num_indexes,
-                                   uint16_t* indexes, uint16_t base_index) {
+void bit_util::bits_to_indexes_avx2(int bit_to_search, const int num_bits,
+                                    const uint8_t* bits, int* num_indexes,
+                                    uint16_t* indexes, uint16_t base_index) {
   if (bit_to_search == 0) {
     bits_to_indexes_imp_avx2<0>(num_bits, bits, num_indexes, indexes, base_index);
   } else {
@@ -37,9 +37,9 @@ void BitUtil::bits_to_indexes_avx2(int bit_to_search, const int num_bits,
 }
 
 template <int bit_to_search>
-void BitUtil::bits_to_indexes_imp_avx2(const int num_bits, const uint8_t* bits,
-                                       int* num_indexes, uint16_t* indexes,
-                                       uint16_t base_index) {
+void bit_util::bits_to_indexes_imp_avx2(const int num_bits, const uint8_t* bits,
+                                        int* num_indexes, uint16_t* indexes,
+                                        uint16_t base_index) {
   // 64 bits at a time
   constexpr int unroll = 64;
 
@@ -67,7 +67,7 @@ void BitUtil::bits_to_indexes_imp_avx2(const int num_bits, const uint8_t* bits,
           _pext_u64(mask, _pdep_u64(word, kEachByteIs1) * 0xff) + base;
       *reinterpret_cast<uint64_t*>(byte_indexes + num_indexes_loop) = byte_indexes_next;
       base += incr;
-      num_indexes_loop += static_cast<int>(arrow::BitUtil::PopCount(word & 0xff));
+      num_indexes_loop += static_cast<int>(arrow::bit_util::PopCount(word & 0xff));
       word >>= 8;
     }
     // Unpack indexes to 16-bits and either add the base of i * 64 or shuffle input
@@ -82,9 +82,10 @@ void BitUtil::bits_to_indexes_imp_avx2(const int num_bits, const uint8_t* bits,
   }
 }
 
-void BitUtil::bits_filter_indexes_avx2(int bit_to_search, const int num_bits,
-                                       const uint8_t* bits, const uint16_t* input_indexes,
-                                       int* num_indexes, uint16_t* indexes) {
+void bit_util::bits_filter_indexes_avx2(int bit_to_search, const int num_bits,
+                                        const uint8_t* bits,
+                                        const uint16_t* input_indexes, int* num_indexes,
+                                        uint16_t* indexes) {
   if (bit_to_search == 0) {
     bits_filter_indexes_imp_avx2<0>(num_bits, bits, input_indexes, num_indexes, indexes);
   } else {
@@ -93,9 +94,9 @@ void BitUtil::bits_filter_indexes_avx2(int bit_to_search, const int num_bits,
 }
 
 template <int bit_to_search>
-void BitUtil::bits_filter_indexes_imp_avx2(const int num_bits, const uint8_t* bits,
-                                           const uint16_t* input_indexes,
-                                           int* out_num_indexes, uint16_t* indexes) {
+void bit_util::bits_filter_indexes_imp_avx2(const int num_bits, const uint8_t* bits,
+                                            const uint16_t* input_indexes,
+                                            int* out_num_indexes, uint16_t* indexes) {
   // 64 bits at a time
   constexpr int unroll = 64;
 
@@ -157,7 +158,7 @@ void BitUtil::bits_filter_indexes_imp_avx2(const int num_bits, const uint8_t* bi
                                                       kByteSequence_0_8_1_9_2_10_3_11,
                                                       kByteSequence_4_12_5_13_6_14_7_15));
       _mm256_storeu_si256((__m256i*)(indexes + num_indexes), output);
-      num_indexes += static_cast<int>(arrow::BitUtil::PopCount(word & 0xffff));
+      num_indexes += static_cast<int>(arrow::bit_util::PopCount(word & 0xffff));
       word >>= 16;
       ++loop_id;
     }
@@ -166,8 +167,8 @@ void BitUtil::bits_filter_indexes_imp_avx2(const int num_bits, const uint8_t* bi
   *out_num_indexes = num_indexes;
 }
 
-void BitUtil::bits_to_bytes_avx2(const int num_bits, const uint8_t* bits,
-                                 uint8_t* bytes) {
+void bit_util::bits_to_bytes_avx2(const int num_bits, const uint8_t* bits,
+                                  uint8_t* bytes) {
   constexpr int unroll = 32;
 
   constexpr uint64_t kEachByteIs1 = 0x0101010101010101ULL;
@@ -187,8 +188,8 @@ void BitUtil::bits_to_bytes_avx2(const int num_bits, const uint8_t* bits,
   }
 }
 
-void BitUtil::bytes_to_bits_avx2(const int num_bits, const uint8_t* bytes,
-                                 uint8_t* bits) {
+void bit_util::bytes_to_bits_avx2(const int num_bits, const uint8_t* bytes,
+                                  uint8_t* bits) {
   constexpr int unroll = 32;
   // Processing 32 bits at a time
   for (int i = 0; i < num_bits / unroll; ++i) {
@@ -197,7 +198,7 @@ void BitUtil::bytes_to_bits_avx2(const int num_bits, const uint8_t* bytes,
   }
 }
 
-bool BitUtil::are_all_bytes_zero_avx2(const uint8_t* bytes, uint32_t num_bytes) {
+bool bit_util::are_all_bytes_zero_avx2(const uint8_t* bytes, uint32_t num_bytes) {
   __m256i result_or = _mm256_setzero_si256();
   uint32_t i;
   for (i = 0; i < num_bytes / 32; ++i) {
diff --git a/cpp/src/arrow/compute/exec_test.cc b/cpp/src/arrow/compute/exec_test.cc
index 3769517a9e4..198cb84ff5e 100644
--- a/cpp/src/arrow/compute/exec_test.cc
+++ b/cpp/src/arrow/compute/exec_test.cc
@@ -95,7 +95,7 @@ void AssertValidityZeroExtraBits(const ArrayData& arr) {
 
   const int64_t bit_extent = ((arr.offset + arr.length + 7) / 8) * 8;
   for (int64_t i = arr.offset + arr.length; i < bit_extent; ++i) {
-    EXPECT_FALSE(BitUtil::GetBit(buf.data(), i)) << i;
+    EXPECT_FALSE(bit_util::GetBit(buf.data(), i)) << i;
   }
 }
 
@@ -253,7 +253,7 @@ TEST_F(TestPropagateNulls, SingleValueWithNulls) {
     if (preallocate) {
       ASSERT_OK_AND_ASSIGN(
           preallocated_bitmap,
-          AllocateBuffer(BitUtil::BytesForBits(sliced->length() + out_offset)));
+          AllocateBuffer(bit_util::BytesForBits(sliced->length() + out_offset)));
       std::memset(preallocated_bitmap->mutable_data(), 0, preallocated_bitmap->size());
       output.buffers[0] = preallocated_bitmap;
     } else {
diff --git a/cpp/src/arrow/compute/function_test.cc b/cpp/src/arrow/compute/function_test.cc
index 626824d73ec..b503a1732d9 100644
--- a/cpp/src/arrow/compute/function_test.cc
+++ b/cpp/src/arrow/compute/function_test.cc
@@ -125,6 +125,8 @@ TEST(FunctionOptions, Equality) {
   options.emplace_back(new PartitionNthOptions(/*pivot=*/42));
   options.emplace_back(new SelectKOptions(0, {}));
   options.emplace_back(new SelectKOptions(5, {{SortKey("key", SortOrder::Ascending)}}));
+  options.emplace_back(new Utf8NormalizeOptions());
+  options.emplace_back(new Utf8NormalizeOptions(Utf8NormalizeOptions::NFD));
 
   for (size_t i = 0; i < options.size(); i++) {
     const size_t prev_i = i == 0 ? options.size() - 1 : i - 1;
diff --git a/cpp/src/arrow/compute/kernel.cc b/cpp/src/arrow/compute/kernel.cc
index 666b73e415c..909c2399c8e 100644
--- a/cpp/src/arrow/compute/kernel.cc
+++ b/cpp/src/arrow/compute/kernel.cc
@@ -49,7 +49,7 @@ Result<std::shared_ptr<ResizableBuffer>> KernelContext::Allocate(int64_t nbytes)
 }
 
 Result<std::shared_ptr<ResizableBuffer>> KernelContext::AllocateBitmap(int64_t num_bits) {
-  const int64_t nbytes = BitUtil::BytesForBits(num_bits);
+  const int64_t nbytes = bit_util::BytesForBits(num_bits);
   ARROW_ASSIGN_OR_RAISE(std::shared_ptr<ResizableBuffer> result,
                         AllocateResizableBuffer(nbytes, exec_ctx_->memory_pool()));
   // Since bitmaps are typically written bit by bit, we could leak uninitialized bits.
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index 38575553b3e..c5aaffda8fc 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -259,7 +259,7 @@ Result<std::unique_ptr<KernelState>> SumInit(KernelContext* ctx,
 
 Result<std::unique_ptr<KernelState>> MeanInit(KernelContext* ctx,
                                               const KernelInitArgs& args) {
-  SumLikeInit<MeanImplDefault> visitor(
+  MeanKernelInit<MeanImplDefault> visitor(
       ctx, args.inputs[0].type,
       static_cast<const ScalarAggregateOptions&>(*args.options));
   return visitor.Create();
@@ -929,6 +929,7 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
   AddArrayScalarAggKernels(SumInit, SignedIntTypes(), int64(), func.get());
   AddArrayScalarAggKernels(SumInit, UnsignedIntTypes(), uint64(), func.get());
   AddArrayScalarAggKernels(SumInit, FloatingPointTypes(), float64(), func.get());
+  AddArrayScalarAggKernels(SumInit, {null()}, int64(), func.get());
   // Add the SIMD variants for sum
 #if defined(ARROW_HAVE_RUNTIME_AVX2) || defined(ARROW_HAVE_RUNTIME_AVX512)
   auto cpu_info = arrow::internal::CpuInfo::GetInstance();
@@ -955,6 +956,7 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
   AddAggKernel(
       KernelSignature::Make({InputType(Type::DECIMAL256)}, OutputType(ScalarFirstType)),
       MeanInit, func.get(), SimdLevel::NONE);
+  AddArrayScalarAggKernels(MeanInit, {null()}, float64(), func.get());
   // Add the SIMD variants for mean
 #if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (cpu_info->IsSupported(arrow::internal::CpuInfo::AVX2)) {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
index e56fab21c16..8f020160255 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
@@ -121,6 +121,40 @@ struct SumImpl : public ScalarAggregator {
   ScalarAggregateOptions options;
 };
 
+template <typename ArrowType>
+struct NullSumImpl : public ScalarAggregator {
+  using ScalarType = typename TypeTraits<ArrowType>::ScalarType;
+
+  explicit NullSumImpl(const ScalarAggregateOptions& options_) : options(options_) {}
+
+  Status Consume(KernelContext*, const ExecBatch& batch) override {
+    if (batch[0].is_scalar() || batch[0].array()->GetNullCount() > 0) {
+      // If the batch is a scalar or an array with elements, set is_empty to false
+      is_empty = false;
+    }
+    return Status::OK();
+  }
+
+  Status MergeFrom(KernelContext*, KernelState&& src) override {
+    const auto& other = checked_cast<const NullSumImpl&>(src);
+    this->is_empty &= other.is_empty;
+    return Status::OK();
+  }
+
+  Status Finalize(KernelContext*, Datum* out) override {
+    if ((options.skip_nulls || this->is_empty) && options.min_count == 0) {
+      // Return 0 if the remaining data is empty
+      out->value = std::make_shared<ScalarType>(0);
+    } else {
+      out->value = MakeNullScalar(TypeTraits<ArrowType>::type_singleton());
+    }
+    return Status::OK();
+  }
+
+  bool is_empty = true;
+  ScalarAggregateOptions options;
+};
+
 template <typename ArrowType, SimdLevel::type SimdLevel>
 struct MeanImpl : public SumImpl<ArrowType, SimdLevel> {
   using SumImpl<ArrowType, SimdLevel>::SumImpl;
@@ -200,12 +234,29 @@ struct SumLikeInit {
     return Status::OK();
   }
 
+  virtual Status Visit(const NullType&) {
+    state.reset(new NullSumImpl<Int64Type>(options));
+    return Status::OK();
+  }
+
   Result<std::unique_ptr<KernelState>> Create() {
     RETURN_NOT_OK(VisitTypeInline(*type, this));
     return std::move(state);
   }
 };
 
+template <template <typename> class KernelClass>
+struct MeanKernelInit : public SumLikeInit<KernelClass> {
+  MeanKernelInit(KernelContext* ctx, const std::shared_ptr<DataType>& type,
+                 const ScalarAggregateOptions& options)
+      : SumLikeInit<KernelClass>(ctx, type, options) {}
+
+  Status Visit(const NullType&) override {
+    this->state.reset(new NullSumImpl<DoubleType>(this->options));
+    return Status::OK();
+  }
+};
+
 // ----------------------------------------------------------------------
 // MinMax implementation
 
@@ -454,7 +505,7 @@ struct MinMaxImpl : public ScalarAggregator {
     // First handle the leading bits
     const int64_t leading_bits = p.leading_bits;
     while (idx < leading_bits) {
-      if (BitUtil::GetBit(bitmap, offset)) {
+      if (bit_util::GetBit(bitmap, offset)) {
         local.MergeOne(arr.GetView(idx));
       }
       idx++;
diff --git a/cpp/src/arrow/compute/kernels/aggregate_benchmark.cc b/cpp/src/arrow/compute/kernels/aggregate_benchmark.cc
index 5aef6d5f12e..2507ef7fcda 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_benchmark.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_benchmark.cc
@@ -36,7 +36,7 @@ namespace compute {
 
 #ifdef ARROW_WITH_BENCHMARKS_REFERENCE
 
-namespace BitUtil = arrow::BitUtil;
+namespace bit_util = arrow::bit_util;
 using arrow::internal::BitmapReader;
 
 template <typename T>
@@ -104,7 +104,7 @@ struct SumNoNullsUnrolled : public Summer<T> {
 
     const auto values = array.raw_values();
     const auto length = array.length();
-    const int64_t length_rounded = BitUtil::RoundDown(length, 8);
+    const int64_t length_rounded = bit_util::RoundDown(length, 8);
     for (int64_t i = 0; i < length_rounded; i += 8) {
       local.total += values[i + 0] + values[i + 1] + values[i + 2] + values[i + 3] +
                      values[i + 4] + values[i + 5] + values[i + 6] + values[i + 7];
@@ -154,7 +154,7 @@ struct SumSentinelUnrolled : public Summer<T> {
 
     const auto values = array.raw_values();
     const auto length = array.length();
-    const int64_t length_rounded = BitUtil::RoundDown(length, 8);
+    const int64_t length_rounded = bit_util::RoundDown(length, 8);
     for (int64_t i = 0; i < length_rounded; i += 8) {
       SUM_NOT_NULL(0);
       SUM_NOT_NULL(1);
@@ -189,7 +189,7 @@ struct SumBitmapNaive : public Summer<T> {
     const auto length = array.length();
 
     for (int64_t i = 0; i < length; ++i) {
-      if (BitUtil::GetBit(bitmap, i)) {
+      if (bit_util::GetBit(bitmap, i)) {
         local.total += values[i];
         ++local.valid_count;
       }
@@ -233,7 +233,7 @@ struct SumBitmapVectorizeUnroll : public Summer<T> {
     const auto values = array.raw_values();
     const auto bitmap = array.null_bitmap_data();
     const auto length = array.length();
-    const int64_t length_rounded = BitUtil::RoundDown(length, 8);
+    const int64_t length_rounded = bit_util::RoundDown(length, 8);
     for (int64_t i = 0; i < length_rounded; i += 8) {
       const uint8_t valid_byte = bitmap[i / 8];
 
@@ -249,7 +249,7 @@ struct SumBitmapVectorizeUnroll : public Summer<T> {
         local.total += SUM_SHIFT(5);
         local.total += SUM_SHIFT(6);
         local.total += SUM_SHIFT(7);
-        local.valid_count += BitUtil::kBytePopcount[valid_byte];
+        local.valid_count += bit_util::kBytePopcount[valid_byte];
       } else {
         // No nulls
         local.total += values[i + 0] + values[i + 1] + values[i + 2] + values[i + 3] +
@@ -261,7 +261,7 @@ struct SumBitmapVectorizeUnroll : public Summer<T> {
 #undef SUM_SHIFT
 
     for (int64_t i = length_rounded; i < length; ++i) {
-      if (BitUtil::GetBit(bitmap, i)) {
+      if (bit_util::GetBit(bitmap, i)) {
         local.total = values[i];
         ++local.valid_count;
       }
diff --git a/cpp/src/arrow/compute/kernels/aggregate_internal.h b/cpp/src/arrow/compute/kernels/aggregate_internal.h
index 946ec01900c..07378e3ce82 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_internal.h
@@ -153,7 +153,7 @@ enable_if_t<std::is_floating_point<SumType>::value, SumType> SumArray(
   // number of inputs to accumulate before merging with another block
   constexpr int kBlockSize = 16;  // same as numpy
   // levels (tree depth) = ceil(log2(len)) + 1, a bit larger than necessary
-  const int levels = BitUtil::Log2(static_cast<uint64_t>(data_size)) + 1;
+  const int levels = bit_util::Log2(static_cast<uint64_t>(data_size)) + 1;
   // temporary summation per level
   std::vector<SumType> sum(levels);
   // whether two summations are ready and should be reduced to upper level
diff --git a/cpp/src/arrow/compute/kernels/aggregate_quantile.cc b/cpp/src/arrow/compute/kernels/aggregate_quantile.cc
index cd2410cc9eb..9d36471fb3b 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_quantile.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_quantile.cc
@@ -424,13 +424,13 @@ Status ScalarQuantile(KernelContext* ctx, const QuantileOptions& options,
   auto out_type = IsDataPoint(options) ? scalar.type : float64();
   ARROW_ASSIGN_OR_RAISE(
       output->buffers[1],
-      ctx->Allocate(output->length * BitUtil::BytesForBits(GetBitWidth(*out_type))));
+      ctx->Allocate(output->length * bit_util::BytesForBits(GetBitWidth(*out_type))));
 
   if (!scalar.is_valid || options.min_count > 1) {
     output->null_count = output->length;
     ARROW_ASSIGN_OR_RAISE(output->buffers[0], ctx->AllocateBitmap(output->length));
-    BitUtil::SetBitsTo(output->buffers[0]->mutable_data(), /*offset=*/0, output->length,
-                       false);
+    bit_util::SetBitsTo(output->buffers[0]->mutable_data(), /*offset=*/0, output->length,
+                        false);
     if (IsDataPoint(options)) {
       CType* out_buffer = output->template GetMutableValues<CType>(1);
       std::fill(out_buffer, out_buffer + output->length, CType(0));
diff --git a/cpp/src/arrow/compute/kernels/aggregate_test.cc b/cpp/src/arrow/compute/kernels/aggregate_test.cc
index 63a4dc0bc14..52751d93cc4 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_test.cc
@@ -591,6 +591,32 @@ TEST(TestDecimalSumKernel, ScalarAggregateOptions) {
   }
 }
 
+TEST(TestNullSumKernel, Basics) {
+  auto ty = null();
+  Datum null_result = std::make_shared<Int64Scalar>();
+  Datum zero_result = std::make_shared<Int64Scalar>(0);
+
+  EXPECT_THAT(Sum(ScalarFromJSON(ty, "null")), ResultWith(null_result));
+  EXPECT_THAT(Sum(ArrayFromJSON(ty, "[]")), ResultWith(null_result));
+  EXPECT_THAT(Sum(ArrayFromJSON(ty, "[null]")), ResultWith(null_result));
+  EXPECT_THAT(Sum(ChunkedArrayFromJSON(ty, {"[null]", "[]", "[null, null]"})),
+              ResultWith(null_result));
+
+  ScalarAggregateOptions options(/*skip_nulls=*/true, /*min_count=*/0);
+  EXPECT_THAT(Sum(ScalarFromJSON(ty, "null"), options), ResultWith(zero_result));
+  EXPECT_THAT(Sum(ArrayFromJSON(ty, "[]"), options), ResultWith(zero_result));
+  EXPECT_THAT(Sum(ArrayFromJSON(ty, "[null]"), options), ResultWith(zero_result));
+  EXPECT_THAT(Sum(ChunkedArrayFromJSON(ty, {"[null]", "[]", "[null, null]"}), options),
+              ResultWith(zero_result));
+
+  options = ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/0);
+  EXPECT_THAT(Sum(ScalarFromJSON(ty, "null"), options), ResultWith(null_result));
+  EXPECT_THAT(Sum(ArrayFromJSON(ty, "[]"), options), ResultWith(zero_result));
+  EXPECT_THAT(Sum(ArrayFromJSON(ty, "[null]"), options), ResultWith(null_result));
+  EXPECT_THAT(Sum(ChunkedArrayFromJSON(ty, {"[null]", "[]", "[null, null]"}), options),
+              ResultWith(null_result));
+}
+
 //
 // Product
 //
@@ -1354,6 +1380,32 @@ TEST(TestDecimalMeanKernel, ScalarAggregateOptions) {
   }
 }
 
+TEST(TestNullMeanKernel, Basics) {
+  auto ty = null();
+  Datum null_result = std::make_shared<DoubleScalar>();
+  Datum zero_result = std::make_shared<DoubleScalar>(0);
+
+  EXPECT_THAT(Mean(ScalarFromJSON(ty, "null")), ResultWith(null_result));
+  EXPECT_THAT(Mean(ArrayFromJSON(ty, "[]")), ResultWith(null_result));
+  EXPECT_THAT(Mean(ArrayFromJSON(ty, "[null]")), ResultWith(null_result));
+  EXPECT_THAT(Mean(ChunkedArrayFromJSON(ty, {"[null]", "[]", "[null, null]"})),
+              ResultWith(null_result));
+
+  ScalarAggregateOptions options(/*skip_nulls=*/true, /*min_count=*/0);
+  EXPECT_THAT(Mean(ScalarFromJSON(ty, "null"), options), ResultWith(zero_result));
+  EXPECT_THAT(Mean(ArrayFromJSON(ty, "[]"), options), ResultWith(zero_result));
+  EXPECT_THAT(Mean(ArrayFromJSON(ty, "[null]"), options), ResultWith(zero_result));
+  EXPECT_THAT(Mean(ChunkedArrayFromJSON(ty, {"[null]", "[]", "[null, null]"}), options),
+              ResultWith(zero_result));
+
+  options = ScalarAggregateOptions(/*skip_nulls=*/false, /*min_count=*/0);
+  EXPECT_THAT(Mean(ScalarFromJSON(ty, "null"), options), ResultWith(null_result));
+  EXPECT_THAT(Mean(ArrayFromJSON(ty, "[]"), options), ResultWith(zero_result));
+  EXPECT_THAT(Mean(ArrayFromJSON(ty, "[null]"), options), ResultWith(null_result));
+  EXPECT_THAT(Mean(ChunkedArrayFromJSON(ty, {"[null]", "[]", "[null, null]"}), options),
+              ResultWith(null_result));
+}
+
 //
 // Min / Max
 //
@@ -3451,7 +3503,7 @@ TEST_F(TestInt64QuantileKernel, Int64) {
 #undef DOUBLE
 #undef O
 
-#ifndef __MINGW32__
+#if !defined(__MINGW32__) && !defined(__i386__)
 template <typename ArrowType>
 class TestRandomQuantileKernel : public TestPrimitiveQuantileKernel<ArrowType> {
   using CType = typename ArrowType::c_type;
@@ -3582,7 +3634,7 @@ class TestRandomQuantileKernel : public TestPrimitiveQuantileKernel<ArrowType> {
       const CType* values = array->data()->GetValues<CType>(1);
       const auto bitmap = array->null_bitmap_data();
       for (int64_t i = 0; i < array->length(); ++i) {
-        if ((!bitmap || BitUtil::GetBit(bitmap, array->data()->offset + i)) &&
+        if ((!bitmap || bit_util::GetBit(bitmap, array->data()->offset + i)) &&
             !std::isnan(static_cast<double>(values[i]))) {
           input[index++] = values[i];
         }
diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.cc b/cpp/src/arrow/compute/kernels/codegen_internal.cc
index 209c433db20..eef5c4081bc 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.cc
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.cc
@@ -170,7 +170,7 @@ std::shared_ptr<DataType> CommonNumeric(const ValueDescr* begin, size_t count) {
   }
 
   if (max_width_signed <= max_width_unsigned) {
-    max_width_signed = static_cast<int>(BitUtil::NextPower2(max_width_unsigned + 1));
+    max_width_signed = static_cast<int>(bit_util::NextPower2(max_width_unsigned + 1));
   }
 
   if (max_width_signed >= 64) return int64();
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate.cc b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
index 3ee19ca1ee8..a982aec4372 100644
--- a/cpp/src/arrow/compute/kernels/hash_aggregate.cc
+++ b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
@@ -368,9 +368,9 @@ struct GrouperFastImpl : Grouper {
       }
       auto ids = util::TempVectorHolder<uint16_t>(&temp_stack_, batch_size_next);
       int num_ids;
-      util::BitUtil::bits_to_indexes(0, encode_ctx_.hardware_flags, batch_size_next,
-                                     match_bitvector.mutable_data(), &num_ids,
-                                     ids.mutable_data());
+      util::bit_util::bits_to_indexes(0, encode_ctx_.hardware_flags, batch_size_next,
+                                      match_bitvector.mutable_data(), &num_ids,
+                                      ids.mutable_data());
 
       RETURN_NOT_OK(map_.map_new_keys(
           num_ids, ids.mutable_data(), minibatch_hashes_.data(),
@@ -394,7 +394,7 @@ struct GrouperFastImpl : Grouper {
     ARROW_ASSIGN_OR_RAISE(
         std::shared_ptr<Buffer> buf,
         AllocateBitmap(length + kBitmapPaddingForSIMD, ctx_->memory_pool()));
-    return SliceMutableBuffer(buf, 0, BitUtil::BytesForBits(length));
+    return SliceMutableBuffer(buf, 0, bit_util::BytesForBits(length));
   }
 
   Result<std::shared_ptr<Buffer>> AllocatePaddedBuffer(int64_t size) {
@@ -598,10 +598,10 @@ struct GroupedValueTraits {
 template <>
 struct GroupedValueTraits<BooleanType> {
   static bool Get(const uint8_t* values, uint32_t g) {
-    return BitUtil::GetBit(values, g);
+    return bit_util::GetBit(values, g);
   }
   static void Set(uint8_t* values, uint32_t g, bool v) {
-    BitUtil::SetBitTo(values, g, v);
+    bit_util::SetBitTo(values, g, v);
   }
 };
 
@@ -715,7 +715,7 @@ struct GroupedCountImpl : public GroupedAggregator {
         if (input->MayHaveNulls()) {
           auto end = input->offset + input->length;
           for (int64_t i = input->offset; i < end; ++i, ++g_begin) {
-            counts[*g_begin] += !BitUtil::GetBit(input->buffers[0]->data(), i);
+            counts[*g_begin] += !bit_util::GetBit(input->buffers[0]->data(), i);
           }
         }
       }
@@ -786,7 +786,7 @@ struct GroupedReducingAggregator : public GroupedAggregator {
           reduced[g] = Impl::Reduce(*out_type_, reduced[g], value);
           counts[g]++;
         },
-        [&](uint32_t g) { BitUtil::SetBitTo(no_nulls, g, false); });
+        [&](uint32_t g) { bit_util::SetBitTo(no_nulls, g, false); });
     return Status::OK();
   }
 
@@ -806,9 +806,9 @@ struct GroupedReducingAggregator : public GroupedAggregator {
     for (int64_t other_g = 0; other_g < group_id_mapping.length; ++other_g, ++g) {
       counts[*g] += other_counts[other_g];
       reduced[*g] = Impl::Reduce(*out_type_, reduced[*g], other_reduced[other_g]);
-      BitUtil::SetBitTo(
+      bit_util::SetBitTo(
           no_nulls, *g,
-          BitUtil::GetBit(no_nulls, *g) && BitUtil::GetBit(other_no_nulls, other_g));
+          bit_util::GetBit(no_nulls, *g) && bit_util::GetBit(other_no_nulls, other_g));
     }
     return Status::OK();
   }
@@ -825,11 +825,11 @@ struct GroupedReducingAggregator : public GroupedAggregator {
 
       if ((*null_bitmap) == nullptr) {
         ARROW_ASSIGN_OR_RAISE(*null_bitmap, AllocateBitmap(num_groups, pool));
-        BitUtil::SetBitsTo((*null_bitmap)->mutable_data(), 0, num_groups, true);
+        bit_util::SetBitsTo((*null_bitmap)->mutable_data(), 0, num_groups, true);
       }
 
       (*null_count)++;
-      BitUtil::SetBitTo((*null_bitmap)->mutable_data(), i, false);
+      bit_util::SetBitTo((*null_bitmap)->mutable_data(), i, false);
     }
     return reduced->Finish();
   }
@@ -1043,11 +1043,11 @@ struct GroupedMeanImpl : public GroupedReducingAggregator<Type, GroupedMeanImpl<
 
       if ((*null_bitmap) == nullptr) {
         ARROW_ASSIGN_OR_RAISE(*null_bitmap, AllocateBitmap(num_groups, pool));
-        BitUtil::SetBitsTo((*null_bitmap)->mutable_data(), 0, num_groups, true);
+        bit_util::SetBitsTo((*null_bitmap)->mutable_data(), 0, num_groups, true);
       }
 
       (*null_count)++;
-      BitUtil::SetBitTo((*null_bitmap)->mutable_data(), i, false);
+      bit_util::SetBitTo((*null_bitmap)->mutable_data(), i, false);
     }
     return std::move(values);
   }
@@ -1139,7 +1139,7 @@ struct GroupedVarStdImpl : public GroupedAggregator {
           sums[g] += value;
           counts[g]++;
         },
-        [&](uint32_t g) { BitUtil::ClearBit(no_nulls, g); });
+        [&](uint32_t g) { bit_util::ClearBit(no_nulls, g); });
 
     for (int64_t i = 0; i < num_groups_; i++) {
       means[i] = ToDouble(sums[i]) / counts[i];
@@ -1175,7 +1175,7 @@ struct GroupedVarStdImpl : public GroupedAggregator {
     if (batch[0].is_scalar() && !batch[0].scalar()->is_valid) {
       uint8_t* no_nulls = no_nulls_.mutable_data();
       for (int64_t i = 0; i < batch.length; i++) {
-        BitUtil::ClearBit(no_nulls, g[i]);
+        bit_util::ClearBit(no_nulls, g[i]);
       }
       return Status::OK();
     }
@@ -1227,7 +1227,7 @@ struct GroupedVarStdImpl : public GroupedAggregator {
               visit_values(position, run.length);
             } else {
               for (int64_t i = 0; i < run.length; ++i) {
-                BitUtil::ClearBit(other_no_nulls, g[start_index + position + i]);
+                bit_util::ClearBit(other_no_nulls, g[start_index + position + i]);
               }
             }
             position += run.length;
@@ -1272,8 +1272,8 @@ struct GroupedVarStdImpl : public GroupedAggregator {
 
     auto g = group_id_mapping.GetValues<uint32_t>(1);
     for (int64_t other_g = 0; other_g < group_id_mapping.length; ++other_g, ++g) {
-      if (!BitUtil::GetBit(other_no_nulls, other_g)) {
-        BitUtil::ClearBit(no_nulls, *g);
+      if (!bit_util::GetBit(other_no_nulls, other_g)) {
+        bit_util::ClearBit(no_nulls, *g);
       }
       if (other_counts[other_g] == 0) continue;
       MergeVarStd(counts[*g], means[*g], other_counts[other_g], other_means[other_g],
@@ -1301,11 +1301,11 @@ struct GroupedVarStdImpl : public GroupedAggregator {
       results[i] = 0;
       if (null_bitmap == nullptr) {
         ARROW_ASSIGN_OR_RAISE(null_bitmap, AllocateBitmap(num_groups_, pool_));
-        BitUtil::SetBitsTo(null_bitmap->mutable_data(), 0, num_groups_, true);
+        bit_util::SetBitsTo(null_bitmap->mutable_data(), 0, num_groups_, true);
       }
 
       null_count += 1;
-      BitUtil::SetBitTo(null_bitmap->mutable_data(), i, false);
+      bit_util::SetBitTo(null_bitmap->mutable_data(), i, false);
     }
     if (!options_.skip_nulls) {
       if (null_bitmap) {
@@ -1428,7 +1428,7 @@ struct GroupedTDigestImpl : public GroupedAggregator {
           tdigests_[g].NanAdd(ToDouble(value));
           counts[g]++;
         },
-        [&](uint32_t g) { BitUtil::SetBitTo(no_nulls, g, false); });
+        [&](uint32_t g) { bit_util::SetBitTo(no_nulls, g, false); });
     return Status::OK();
   }
 
@@ -1446,9 +1446,9 @@ struct GroupedTDigestImpl : public GroupedAggregator {
     for (int64_t other_g = 0; other_g < group_id_mapping.length; ++other_g, ++g) {
       tdigests_[*g].Merge(other->tdigests_[other_g]);
       counts[*g] += other_counts[other_g];
-      BitUtil::SetBitTo(
+      bit_util::SetBitTo(
           no_nulls, *g,
-          BitUtil::GetBit(no_nulls, *g) && BitUtil::GetBit(other_no_nulls, other_g));
+          bit_util::GetBit(no_nulls, *g) && bit_util::GetBit(other_no_nulls, other_g));
     }
 
     return Status::OK();
@@ -1466,7 +1466,7 @@ struct GroupedTDigestImpl : public GroupedAggregator {
     double* results = reinterpret_cast<double*>(values->mutable_data());
     for (int64_t i = 0; static_cast<size_t>(i) < tdigests_.size(); ++i) {
       if (!tdigests_[i].is_empty() && counts[i] >= options_.min_count &&
-          (options_.skip_nulls || BitUtil::GetBit(no_nulls_.data(), i))) {
+          (options_.skip_nulls || bit_util::GetBit(no_nulls_.data(), i))) {
         for (int64_t j = 0; j < slot_length; j++) {
           results[i * slot_length + j] = tdigests_[i].Quantile(options_.q[j]);
         }
@@ -1475,11 +1475,11 @@ struct GroupedTDigestImpl : public GroupedAggregator {
 
       if (!null_bitmap) {
         ARROW_ASSIGN_OR_RAISE(null_bitmap, AllocateBitmap(num_values, pool_));
-        BitUtil::SetBitsTo(null_bitmap->mutable_data(), 0, num_values, true);
+        bit_util::SetBitsTo(null_bitmap->mutable_data(), 0, num_values, true);
       }
       null_count += slot_length;
-      BitUtil::SetBitsTo(null_bitmap->mutable_data(), i * slot_length, slot_length,
-                         false);
+      bit_util::SetBitsTo(null_bitmap->mutable_data(), i * slot_length, slot_length,
+                          false);
       std::fill(&results[i * slot_length], &results[(i + 1) * slot_length], 0.0);
     }
 
@@ -1642,9 +1642,9 @@ struct GroupedMinMaxImpl final : public GroupedAggregator {
         [&](uint32_t g, CType val) {
           GetSet::Set(raw_mins, g, std::min(GetSet::Get(raw_mins, g), val));
           GetSet::Set(raw_maxes, g, std::max(GetSet::Get(raw_maxes, g), val));
-          BitUtil::SetBit(has_values_.mutable_data(), g);
+          bit_util::SetBit(has_values_.mutable_data(), g);
         },
-        [&](uint32_t g) { BitUtil::SetBit(has_nulls_.mutable_data(), g); });
+        [&](uint32_t g) { bit_util::SetBit(has_nulls_.mutable_data(), g); });
     return Status::OK();
   }
 
@@ -1668,11 +1668,11 @@ struct GroupedMinMaxImpl final : public GroupedAggregator {
           raw_maxes, *g,
           std::max(GetSet::Get(raw_maxes, *g), GetSet::Get(other_raw_maxes, other_g)));
 
-      if (BitUtil::GetBit(other->has_values_.data(), other_g)) {
-        BitUtil::SetBit(has_values_.mutable_data(), *g);
+      if (bit_util::GetBit(other->has_values_.data(), other_g)) {
+        bit_util::SetBit(has_values_.mutable_data(), *g);
       }
-      if (BitUtil::GetBit(other->has_nulls_.data(), other_g)) {
-        BitUtil::SetBit(has_nulls_.mutable_data(), *g);
+      if (bit_util::GetBit(other->has_nulls_.data(), other_g)) {
+        bit_util::SetBit(has_nulls_.mutable_data(), *g);
       }
     }
     return Status::OK();
@@ -1751,11 +1751,11 @@ struct GroupedMinMaxImpl<Type,
           if (!maxes_[g] || val > *maxes_[g]) {
             maxes_[g].emplace(val.data(), val.size(), allocator_);
           }
-          BitUtil::SetBit(has_values_.mutable_data(), g);
+          bit_util::SetBit(has_values_.mutable_data(), g);
           return Status::OK();
         },
         [&](uint32_t g) {
-          BitUtil::SetBit(has_nulls_.mutable_data(), g);
+          bit_util::SetBit(has_nulls_.mutable_data(), g);
           return Status::OK();
         });
   }
@@ -1775,11 +1775,11 @@ struct GroupedMinMaxImpl<Type,
         maxes_[*g] = std::move(other->maxes_[other_g]);
       }
 
-      if (BitUtil::GetBit(other->has_values_.data(), other_g)) {
-        BitUtil::SetBit(has_values_.mutable_data(), *g);
+      if (bit_util::GetBit(other->has_values_.data(), other_g)) {
+        bit_util::SetBit(has_values_.mutable_data(), *g);
       }
-      if (BitUtil::GetBit(other->has_nulls_.data(), other_g)) {
-        BitUtil::SetBit(has_nulls_.mutable_data(), *g);
+      if (bit_util::GetBit(other->has_nulls_.data(), other_g)) {
+        bit_util::SetBit(has_nulls_.mutable_data(), *g);
       }
     }
     return Status::OK();
@@ -1817,7 +1817,7 @@ struct GroupedMinMaxImpl<Type,
     const uint8_t* null_bitmap = array->buffers[0]->data();
     offset_type total_length = 0;
     for (size_t i = 0; i < values.size(); i++) {
-      if (BitUtil::GetBit(null_bitmap, i)) {
+      if (bit_util::GetBit(null_bitmap, i)) {
         const util::optional<StringType>& value = values[i];
         DCHECK(value.has_value());
         if (value->size() >
@@ -1833,7 +1833,7 @@ struct GroupedMinMaxImpl<Type,
     ARROW_ASSIGN_OR_RAISE(auto data, AllocateBuffer(total_length, ctx_->memory_pool()));
     int64_t offset = 0;
     for (size_t i = 0; i < values.size(); i++) {
-      if (BitUtil::GetBit(null_bitmap, i)) {
+      if (bit_util::GetBit(null_bitmap, i)) {
         const util::optional<StringType>& value = values[i];
         DCHECK(value.has_value());
         std::memcpy(data->mutable_data() + offset, value->data(), value->size());
@@ -1855,7 +1855,7 @@ struct GroupedMinMaxImpl<Type,
     ARROW_ASSIGN_OR_RAISE(auto data, AllocateBuffer(total_length, ctx_->memory_pool()));
     int64_t offset = 0;
     for (size_t i = 0; i < values.size(); i++) {
-      if (BitUtil::GetBit(null_bitmap, i)) {
+      if (bit_util::GetBit(null_bitmap, i)) {
         const util::optional<StringType>& value = values[i];
         DCHECK(value.has_value());
         std::memcpy(data->mutable_data() + offset, value->data(), slot_width);
@@ -2056,10 +2056,10 @@ struct GroupedBooleanAggregator : public GroupedAggregator {
             input.buffers[0], input.offset, input.length,
             [&](int64_t position) {
               counts[*g]++;
-              Impl::UpdateGroupWith(reduced, *g, BitUtil::GetBit(bitmap, position));
+              Impl::UpdateGroupWith(reduced, *g, bit_util::GetBit(bitmap, position));
               g++;
             },
-            [&] { BitUtil::SetBitTo(no_nulls, *g++, false); });
+            [&] { bit_util::SetBitTo(no_nulls, *g++, false); });
       } else {
         arrow::internal::VisitBitBlocksVoid(
             input.buffers[1], input.offset, input.length,
@@ -2082,7 +2082,7 @@ struct GroupedBooleanAggregator : public GroupedAggregator {
         }
       } else {
         for (int64_t i = 0; i < batch.length; i++) {
-          BitUtil::SetBitTo(no_nulls, *g++, false);
+          bit_util::SetBitTo(no_nulls, *g++, false);
         }
       }
     }
@@ -2104,10 +2104,10 @@ struct GroupedBooleanAggregator : public GroupedAggregator {
     auto g = group_id_mapping.GetValues<uint32_t>(1);
     for (int64_t other_g = 0; other_g < group_id_mapping.length; ++other_g, ++g) {
       counts[*g] += other_counts[other_g];
-      Impl::UpdateGroupWith(reduced, *g, BitUtil::GetBit(other_reduced, other_g));
-      BitUtil::SetBitTo(
+      Impl::UpdateGroupWith(reduced, *g, bit_util::GetBit(other_reduced, other_g));
+      bit_util::SetBitTo(
           no_nulls, *g,
-          BitUtil::GetBit(no_nulls, *g) && BitUtil::GetBit(other_no_nulls, other_g));
+          bit_util::GetBit(no_nulls, *g) && bit_util::GetBit(other_no_nulls, other_g));
     }
     return Status::OK();
   }
@@ -2122,11 +2122,11 @@ struct GroupedBooleanAggregator : public GroupedAggregator {
 
       if (null_bitmap == nullptr) {
         ARROW_ASSIGN_OR_RAISE(null_bitmap, AllocateBitmap(num_groups_, pool_));
-        BitUtil::SetBitsTo(null_bitmap->mutable_data(), 0, num_groups_, true);
+        bit_util::SetBitsTo(null_bitmap->mutable_data(), 0, num_groups_, true);
       }
 
       null_count += 1;
-      BitUtil::SetBitTo(null_bitmap->mutable_data(), i, false);
+      bit_util::SetBitTo(null_bitmap->mutable_data(), i, false);
     }
 
     ARROW_ASSIGN_OR_RAISE(auto reduced, reduced_.Finish());
@@ -2162,8 +2162,8 @@ struct GroupedAnyImpl : public GroupedBooleanAggregator<GroupedAnyImpl> {
 
   // Update the value for a group given an observation.
   static void UpdateGroupWith(uint8_t* seen, uint32_t g, bool value) {
-    if (!BitUtil::GetBit(seen, g) && value) {
-      BitUtil::SetBit(seen, g);
+    if (!bit_util::GetBit(seen, g) && value) {
+      bit_util::SetBit(seen, g);
     }
   }
 
@@ -2180,7 +2180,7 @@ struct GroupedAllImpl : public GroupedBooleanAggregator<GroupedAllImpl> {
 
   static void UpdateGroupWith(uint8_t* seen, uint32_t g, bool value) {
     if (!value) {
-      BitUtil::ClearBit(seen, g);
+      bit_util::ClearBit(seen, g);
     }
   }
 
@@ -2253,11 +2253,11 @@ struct GroupedCountDistinctImpl : public GroupedAggregator {
       }
     } else if (options_.mode == CountOptions::ONLY_VALID) {
       for (int64_t i = 0; i < uniques.length; i++) {
-        counts[g[i]] += BitUtil::GetBit(valid, items.offset + i);
+        counts[g[i]] += bit_util::GetBit(valid, items.offset + i);
       }
     } else if (valid) {  // ONLY_NULL
       for (int64_t i = 0; i < uniques.length; i++) {
-        counts[g[i]] += !BitUtil::GetBit(valid, items.offset + i);
+        counts[g[i]] += !bit_util::GetBit(valid, items.offset + i);
       }
     }
 
diff --git a/cpp/src/arrow/compute/kernels/row_encoder.cc b/cpp/src/arrow/compute/kernels/row_encoder.cc
index 840e4634fc8..10a1f4cda52 100644
--- a/cpp/src/arrow/compute/kernels/row_encoder.cc
+++ b/cpp/src/arrow/compute/kernels/row_encoder.cc
@@ -115,10 +115,10 @@ Result<std::shared_ptr<ArrayData>> BooleanKeyEncoder::Decode(uint8_t** encoded_b
   ARROW_ASSIGN_OR_RAISE(auto key_buf, AllocateBitmap(length, pool));
 
   uint8_t* raw_output = key_buf->mutable_data();
-  memset(raw_output, 0, BitUtil::BytesForBits(length));
+  memset(raw_output, 0, bit_util::BytesForBits(length));
   for (int32_t i = 0; i < length; ++i) {
     auto& encoded_ptr = encoded_bytes[i];
-    BitUtil::SetBitTo(raw_output, i, encoded_ptr[0] != 0);
+    bit_util::SetBitTo(raw_output, i, encoded_ptr[0] != 0);
     encoded_ptr += 1;
   }
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 34cbacb627b..2f36c946f0a 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -459,7 +459,7 @@ struct PowerChecked {
     // left to right O(logn) power with overflow checks
     bool overflow = false;
     uint64_t bitmask =
-        1ULL << (63 - BitUtil::CountLeadingZeros(static_cast<uint64_t>(exp)));
+        1ULL << (63 - bit_util::CountLeadingZeros(static_cast<uint64_t>(exp)));
     T pow = 1;
     while (bitmask) {
       overflow |= MultiplyWithOverflow(pow, pow, &pow);
diff --git a/cpp/src/arrow/compute/kernels/scalar_cast_numeric.cc b/cpp/src/arrow/compute/kernels/scalar_cast_numeric.cc
index 1ce6896deba..3f8b33e9563 100644
--- a/cpp/src/arrow/compute/kernels/scalar_cast_numeric.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_cast_numeric.cc
@@ -104,14 +104,14 @@ Status CheckFloatTruncation(const Datum& input, const Datum& output) {
       // Indices have nulls, must only boundscheck non-null values
       for (int64_t i = 0; i < block.length; ++i) {
         block_out_of_bounds |= WasTruncatedMaybeNull(
-            out_data[i], in_data[i], BitUtil::GetBit(bitmap, offset_position + i));
+            out_data[i], in_data[i], bit_util::GetBit(bitmap, offset_position + i));
       }
     }
     if (ARROW_PREDICT_FALSE(block_out_of_bounds)) {
       if (in_array.GetNullCount() > 0) {
         for (int64_t i = 0; i < block.length; ++i) {
           if (WasTruncatedMaybeNull(out_data[i], in_data[i],
-                                    BitUtil::GetBit(bitmap, offset_position + i))) {
+                                    bit_util::GetBit(bitmap, offset_position + i))) {
             return GetErrorMessage(in_data[i]);
           }
         }
@@ -456,7 +456,7 @@ struct DecimalConversions<Decimal128, Decimal256> {
   // Scale then truncate
   static Decimal256 ConvertInput(Decimal256&& val) { return val; }
   static Decimal128 ConvertOutput(Decimal256&& val) {
-    const auto array_le = BitUtil::LittleEndianArray::Make(val.native_endian_array());
+    const auto array_le = bit_util::little_endian::Make(val.native_endian_array());
     return Decimal128(array_le[1], array_le[0]);
   }
 };
diff --git a/cpp/src/arrow/compute/kernels/scalar_compare.cc b/cpp/src/arrow/compute/kernels/scalar_compare.cc
index c31dc05fc36..d9c3fa77c0c 100644
--- a/cpp/src/arrow/compute/kernels/scalar_compare.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_compare.cc
@@ -420,7 +420,7 @@ struct ScalarMinMax {
           [&](OutValue value) {
             auto u = out_it();
             if (!output->buffers[0] ||
-                BitUtil::GetBit(output->buffers[0]->data(), index)) {
+                bit_util::GetBit(output->buffers[0]->data(), index)) {
               writer.Write(Op::template Call<OutValue, OutValue, OutValue>(u, value));
             } else {
               writer.Write(value);
diff --git a/cpp/src/arrow/compute/kernels/scalar_if_else.cc b/cpp/src/arrow/compute/kernels/scalar_if_else.cc
index cb4ac873b56..bc692ae3fad 100644
--- a/cpp/src/arrow/compute/kernels/scalar_if_else.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_if_else.cc
@@ -108,8 +108,8 @@ Status PromoteNullsVisitor(KernelContext* ctx, const Datum& cond_d, const Datum&
     if (AllocateNullBitmap::value) {  // NullHandling::COMPUTED_NO_PREALLOCATE
       output->buffers[0] = nullptr;
     } else {  // NullHandling::COMPUTED_PREALLOCATE
-      BitUtil::SetBitmap(output->buffers[0]->mutable_data(), output->offset,
-                         output->length);
+      bit_util::SetBitmap(output->buffers[0]->mutable_data(), output->offset,
+                          output->length);
     }
     return Status::OK();
   }
@@ -276,7 +276,7 @@ void RunIfElseLoop(const ArrayData& cond, const HandleBlock& handle_block) {
       handle_block(data_offset, word_len);
     } else if (word != pickNone) {
       for (int64_t i = 0; i < word_len; ++i) {
-        if (BitUtil::GetBit(cond_data, bit_offset + i) != invert) {
+        if (bit_util::GetBit(cond_data, bit_offset + i) != invert) {
           handle_block(data_offset + i, 1);
         }
       }
@@ -298,7 +298,7 @@ void RunIfElseLoop(const ArrayData& cond, const HandleBlock& handle_block) {
       handle_block(data_offset, 8);
     } else if (byte != pickNoneByte) {
       for (int i = 0; i < valid_bits; ++i) {
-        if (BitUtil::GetBit(cond_data, bit_offset + i) != invert) {
+        if (bit_util::GetBit(cond_data, bit_offset + i) != invert) {
           handle_block(data_offset + i, 1);
         }
       }
@@ -332,8 +332,8 @@ Status RunIfElseScalar(const BooleanScalar& cond, const Datum& left, const Datum
   const std::shared_ptr<ArrayData>& out_array = out->array();
   if (!cond.is_valid) {
     // cond is null; output is all null --> clear validity buffer
-    BitUtil::ClearBitmap(out_array->buffers[0]->mutable_data(), out_array->offset,
-                         out_array->length);
+    bit_util::ClearBitmap(out_array->buffers[0]->mutable_data(), out_array->offset,
+                          out_array->length);
     return Status::OK();
   }
 
@@ -347,8 +347,8 @@ Status RunIfElseScalar(const BooleanScalar& cond, const Datum& left, const Datum
           valid_array->buffers[0]->data(), valid_array->offset, valid_array->length,
           out_array->buffers[0]->mutable_data(), out_array->offset);
     } else {  // validity buffer is nullptr --> set all bits
-      BitUtil::SetBitmap(out_array->buffers[0]->mutable_data(), out_array->offset,
-                         out_array->length);
+      bit_util::SetBitmap(out_array->buffers[0]->mutable_data(), out_array->offset,
+                          out_array->length);
     }
     copy_array_data(*valid_array, out_array.get());
     return Status::OK();
@@ -357,12 +357,12 @@ Status RunIfElseScalar(const BooleanScalar& cond, const Datum& left, const Datum
     // valid data is a scalar that needs to be broadcasted
     const auto& valid_scalar = *valid_data.scalar();
     if (valid_scalar.is_valid) {  // if the scalar is non-null, broadcast
-      BitUtil::SetBitmap(out_array->buffers[0]->mutable_data(), out_array->offset,
-                         out_array->length);
+      bit_util::SetBitmap(out_array->buffers[0]->mutable_data(), out_array->offset,
+                          out_array->length);
       broadcast_scalar(*valid_data.scalar(), out_array.get());
     } else {  // scalar is null, clear the output validity buffer
-      BitUtil::ClearBitmap(out_array->buffers[0]->mutable_data(), out_array->offset,
-                           out_array->length);
+      bit_util::ClearBitmap(out_array->buffers[0]->mutable_data(), out_array->offset,
+                            out_array->length);
     }
     return Status::OK();
   }
@@ -496,8 +496,8 @@ struct IfElseFunctor<Type, enable_if_boolean<Type>> {
         /*BroadcastScalar*/
         [&](const Scalar& scalar, ArrayData* out_array) {
           bool scalar_data = internal::UnboxScalar<Type>::Unbox(scalar);
-          BitUtil::SetBitsTo(out_array->buffers[1]->mutable_data(), out_array->offset,
-                             out_array->length, scalar_data);
+          bit_util::SetBitsTo(out_array->buffers[1]->mutable_data(), out_array->offset,
+                              out_array->length, scalar_data);
         });
   }
 
@@ -576,7 +576,7 @@ struct IfElseFunctor<Type, enable_if_boolean<Type>> {
     if (left_data) {
       if (right_data) {
         // out_buf = ones
-        BitUtil::SetBitmap(out_buf->mutable_data(), out->offset, cond.length);
+        bit_util::SetBitmap(out_buf->mutable_data(), out->offset, cond.length);
       } else {
         // out_buf = cond
         arrow::internal::CopyBitmap(cond.buffers[1]->data(), cond.offset, cond.length,
@@ -589,7 +589,7 @@ struct IfElseFunctor<Type, enable_if_boolean<Type>> {
                                       out_buf->mutable_data(), out->offset);
       } else {
         // out_buf = zeros
-        BitUtil::ClearBitmap(out_buf->mutable_data(), out->offset, cond.length);
+        bit_util::ClearBitmap(out_buf->mutable_data(), out->offset, cond.length);
       }
     }
 
@@ -779,15 +779,15 @@ struct IfElseFunctor<Type, enable_if_base_binary<Type>> {
       const auto* out_valid = output.buffers[0]->data();
 
       for (int64_t i = 0; i < cond.length; i++) {
-        if (BitUtil::GetBit(out_valid, i)) {
-          BitUtil::GetBit(cond_data, cond.offset + i) ? handle_left(i) : handle_right(i);
+        if (bit_util::GetBit(out_valid, i)) {
+          bit_util::GetBit(cond_data, cond.offset + i) ? handle_left(i) : handle_right(i);
         } else {
           handle_null();
         }
       }
     } else {  // output is all valid (no nulls)
       for (int64_t i = 0; i < cond.length; i++) {
-        BitUtil::GetBit(cond_data, cond.offset + i) ? handle_left(i) : handle_right(i);
+        bit_util::GetBit(cond_data, cond.offset + i) ? handle_left(i) : handle_right(i);
       }
     }
   }
@@ -1045,7 +1045,7 @@ struct NestedIfElseExec {
         if (run.length == 0) break;
         if (run.set) {
           for (int j = 0; j < run.length; j++) {
-            if (BitUtil::GetBit(cond_data, cond.offset + position + j)) {
+            if (bit_util::GetBit(cond_data, cond.offset + position + j)) {
               RETURN_NOT_OK(handle_left(raw_builder.get(), position + j, 1));
             } else {
               RETURN_NOT_OK(handle_right(raw_builder.get(), position + j, 1));
@@ -1287,7 +1287,7 @@ struct CopyFixedWidth<BooleanType> {
   static void CopyScalar(const Scalar& scalar, const int64_t length,
                          uint8_t* raw_out_values, const int64_t out_offset) {
     const bool value = UnboxScalar<BooleanType>::Unbox(scalar);
-    BitUtil::SetBitsTo(raw_out_values, out_offset, length, value);
+    bit_util::SetBitsTo(raw_out_values, out_offset, length, value);
   }
   static void CopyArray(const DataType&, const uint8_t* in_values,
                         const int64_t in_offset, const int64_t length,
@@ -1351,7 +1351,7 @@ void CopyValues(const Datum& in_values, const int64_t in_offset, const int64_t l
   if (in_values.is_scalar()) {
     const auto& scalar = *in_values.scalar();
     if (out_valid) {
-      BitUtil::SetBitsTo(out_valid, out_offset, length, scalar.is_valid);
+      bit_util::SetBitsTo(out_valid, out_offset, length, scalar.is_valid);
     }
     CopyFixedWidth<Type>::CopyScalar(scalar, length, out_values, out_offset);
   } else {
@@ -1360,15 +1360,15 @@ void CopyValues(const Datum& in_values, const int64_t in_offset, const int64_t l
       if (array.MayHaveNulls()) {
         if (length == 1) {
           // CopyBitmap is slow for short runs
-          BitUtil::SetBitTo(
+          bit_util::SetBitTo(
               out_valid, out_offset,
-              BitUtil::GetBit(array.buffers[0]->data(), array.offset + in_offset));
+              bit_util::GetBit(array.buffers[0]->data(), array.offset + in_offset));
         } else {
           arrow::internal::CopyBitmap(array.buffers[0]->data(), array.offset + in_offset,
                                       length, out_valid, out_offset);
         }
       } else {
-        BitUtil::SetBitsTo(out_valid, out_offset, length, true);
+        bit_util::SetBitsTo(out_valid, out_offset, length, true);
       }
     }
     CopyFixedWidth<Type>::CopyArray(*array.type, array.buffers[1]->data(),
@@ -1386,8 +1386,8 @@ void CopyOneArrayValue(const DataType& type, const uint8_t* in_valid,
                        uint8_t* out_valid, uint8_t* out_values,
                        const int64_t out_offset) {
   if (out_valid) {
-    BitUtil::SetBitTo(out_valid, out_offset,
-                      !in_valid || BitUtil::GetBit(in_valid, in_offset));
+    bit_util::SetBitTo(out_valid, out_offset,
+                       !in_valid || bit_util::GetBit(in_valid, in_offset));
   }
   CopyFixedWidth<Type>::CopyArray(type, in_values, in_offset, /*length=*/1, out_values,
                                   out_offset);
@@ -1397,7 +1397,7 @@ template <typename Type>
 void CopyOneScalarValue(const Scalar& scalar, uint8_t* out_valid, uint8_t* out_values,
                         const int64_t out_offset) {
   if (out_valid) {
-    BitUtil::SetBitTo(out_valid, out_offset, scalar.is_valid);
+    bit_util::SetBitTo(out_valid, out_offset, scalar.is_valid);
   }
   CopyFixedWidth<Type>::CopyScalar(scalar, /*length=*/1, out_values, out_offset);
 }
@@ -1539,7 +1539,7 @@ Status ExecArrayCaseWhen(KernelContext* ctx, const ExecBatch& batch, Datum* out)
                      out_values, out_offset);
   } else {
     // There's no 'else' argument, so we should have an all-null validity bitmap
-    BitUtil::SetBitsTo(out_valid, out_offset, batch.length, false);
+    bit_util::SetBitsTo(out_valid, out_offset, batch.length, false);
   }
 
   // Allocate a temporary bitmap to determine which elements still need setting.
@@ -1564,14 +1564,14 @@ Status ExecArrayCaseWhen(KernelContext* ctx, const ExecBatch& batch, Datum* out)
         if (block.AllSet()) {
           CopyValues<Type>(values_datum, offset, block.length, out_valid, out_values,
                            out_offset + offset);
-          BitUtil::SetBitsTo(mask, offset, block.length, false);
+          bit_util::SetBitsTo(mask, offset, block.length, false);
         } else if (block.popcount) {
           for (int64_t j = 0; j < block.length; ++j) {
-            if (BitUtil::GetBit(mask, offset + j) &&
-                BitUtil::GetBit(cond_values, cond_offset + offset + j)) {
+            if (bit_util::GetBit(mask, offset + j) &&
+                bit_util::GetBit(cond_values, cond_offset + offset + j)) {
               CopyValues<Type>(values_datum, offset + j, /*length=*/1, out_valid,
                                out_values, out_offset + offset + j);
-              BitUtil::SetBitTo(mask, offset + j, false);
+              bit_util::SetBitTo(mask, offset + j, false);
             }
           }
         }
@@ -1589,15 +1589,15 @@ Status ExecArrayCaseWhen(KernelContext* ctx, const ExecBatch& batch, Datum* out)
         if (word == std::numeric_limits<uint64_t>::max()) {
           CopyValues<Type>(values_datum, offset, block_length, out_valid, out_values,
                            out_offset + offset);
-          BitUtil::SetBitsTo(mask, offset, block_length, false);
+          bit_util::SetBitsTo(mask, offset, block_length, false);
         } else if (word) {
           for (int64_t j = 0; j < block_length; ++j) {
-            if (BitUtil::GetBit(mask, offset + j) &&
-                BitUtil::GetBit(cond_valid, cond_offset + offset + j) &&
-                BitUtil::GetBit(cond_values, cond_offset + offset + j)) {
+            if (bit_util::GetBit(mask, offset + j) &&
+                bit_util::GetBit(cond_valid, cond_offset + offset + j) &&
+                bit_util::GetBit(cond_values, cond_offset + offset + j)) {
               CopyValues<Type>(values_datum, offset + j, /*length=*/1, out_valid,
                                out_values, out_offset + offset + j);
-              BitUtil::SetBitTo(mask, offset + j, false);
+              bit_util::SetBitTo(mask, offset + j, false);
             }
           }
         }
@@ -1609,21 +1609,21 @@ Status ExecArrayCaseWhen(KernelContext* ctx, const ExecBatch& batch, Datum* out)
     BitBlockCounter counter(mask, /*offset=*/0, batch.length);
     int64_t offset = 0;
     auto bit_width = checked_cast<const FixedWidthType&>(*out->type()).bit_width();
-    auto byte_width = BitUtil::BytesForBits(bit_width);
+    auto byte_width = bit_util::BytesForBits(bit_width);
     while (offset < batch.length) {
       const auto block = counter.NextWord();
       if (block.AllSet()) {
         if (bit_width == 1) {
-          BitUtil::SetBitsTo(out_values, out_offset + offset, block.length, false);
+          bit_util::SetBitsTo(out_values, out_offset + offset, block.length, false);
         } else {
           std::memset(out_values + (out_offset + offset) * byte_width, 0x00,
                       byte_width * block.length);
         }
       } else if (!block.NoneSet()) {
         for (int64_t j = 0; j < block.length; ++j) {
-          if (BitUtil::GetBit(out_valid, out_offset + offset + j)) continue;
+          if (bit_util::GetBit(out_valid, out_offset + offset + j)) continue;
           if (bit_width == 1) {
-            BitUtil::ClearBit(out_values, out_offset + offset + j);
+            bit_util::ClearBit(out_values, out_offset + offset + j);
           } else {
             std::memset(out_values + (out_offset + offset + j) * byte_width, 0x00,
                         byte_width);
@@ -1711,10 +1711,10 @@ static Status ExecVarWidthArrayCaseWhenImpl(
          arg++) {
       const ArrayData& cond_array = *conds_array.child_data[arg];
       if ((!cond_array.buffers[0] ||
-           BitUtil::GetBit(cond_array.buffers[0]->data(),
-                           conds_array.offset + cond_array.offset + row)) &&
-          BitUtil::GetBit(cond_array.buffers[1]->data(),
-                          conds_array.offset + cond_array.offset + row)) {
+           bit_util::GetBit(cond_array.buffers[0]->data(),
+                            conds_array.offset + cond_array.offset + row)) &&
+          bit_util::GetBit(cond_array.buffers[1]->data(),
+                           conds_array.offset + cond_array.offset + row)) {
         selected = arg + 1;
         break;
       }
@@ -1734,7 +1734,7 @@ static Status ExecVarWidthArrayCaseWhenImpl(
     } else {
       const auto& array = source.array();
       if (!array->buffers[0] ||
-          BitUtil::GetBit(array->buffers[0]->data(), array->offset + row)) {
+          bit_util::GetBit(array->buffers[0]->data(), array->offset + row)) {
         RETURN_NOT_OK(raw_builder->AppendArraySlice(*array, row, /*length=*/1));
       } else {
         RETURN_NOT_OK(raw_builder->AppendNull());
@@ -2021,7 +2021,7 @@ void InitializeNullSlots(const DataType& type, uint8_t* out_valid, uint8_t* out_
   BitRunReader bit_reader(out_valid, out_offset, length);
   int64_t offset = 0;
   const auto bit_width = checked_cast<const FixedWidthType&>(type).bit_width();
-  const auto byte_width = BitUtil::BytesForBits(bit_width);
+  const auto byte_width = bit_util::BytesForBits(bit_width);
   while (true) {
     const auto run = bit_reader.NextRun();
     if (run.length == 0) {
@@ -2029,7 +2029,7 @@ void InitializeNullSlots(const DataType& type, uint8_t* out_valid, uint8_t* out_
     }
     if (!run.set) {
       if (bit_width == 1) {
-        BitUtil::SetBitsTo(out_values, out_offset + offset, run.length, false);
+        bit_util::SetBitsTo(out_values, out_offset + offset, run.length, false);
       } else {
         std::memset(out_values + (out_offset + offset) * byte_width, 0,
                     byte_width * run.length);
@@ -2049,7 +2049,7 @@ Status ExecArrayCoalesce(KernelContext* ctx, const ExecBatch& batch, Datum* out)
   uint8_t* out_valid = output->buffers[0]->mutable_data();
 
   // Clear output validity buffer - no values are set initially
-  BitUtil::SetBitsTo(out_valid, out_offset, batch.length, false);
+  bit_util::SetBitsTo(out_valid, out_offset, batch.length, false);
   uint8_t* out_values = output->buffers[1]->mutable_data();
 
   for (const auto& datum : batch.values) {
@@ -2098,8 +2098,8 @@ Status ExecArrayCoalesce(KernelContext* ctx, const ExecBatch& batch, Datum* out)
                              out_offset + offset);
           } else if (block.popcount) {
             for (int64_t j = 0; j < block.length; ++j) {
-              if (!BitUtil::GetBit(out_valid, out_offset + offset + j) &&
-                  BitUtil::GetBit(in_valid, in_offset + offset + j)) {
+              if (!bit_util::GetBit(out_valid, out_offset + offset + j) &&
+                  bit_util::GetBit(in_valid, in_offset + offset + j)) {
                 // This version lets us avoid calling MayHaveNulls() on every iteration
                 // (which does an atomic load and can add up)
                 CopyOneArrayValue<Type>(type, in_valid, in_values, in_offset + offset + j,
@@ -2174,7 +2174,7 @@ Status ExecArrayScalarCoalesce(KernelContext* ctx, Datum left, Datum right,
   }
 
   if (right_scalar.is_valid || !left_valid) {
-    BitUtil::SetBitsTo(out_valid, out_offset, length, true);
+    bit_util::SetBitsTo(out_valid, out_offset, length, true);
   } else {
     arrow::internal::CopyBitmap(left_valid, left_arr.offset, length, out_valid,
                                 out_offset);
@@ -2247,7 +2247,7 @@ Status ExecBinaryCoalesce(KernelContext* ctx, Datum left, Datum right, int64_t l
   DCHECK_EQ(offset, length);
 
   if (right_null_count == 0) {
-    BitUtil::SetBitsTo(out_valid, out_offset, length, true);
+    bit_util::SetBitsTo(out_valid, out_offset, length, true);
   } else {
     arrow::internal::BitmapOr(left_valid, left_arr.offset, right_valid, right_arr.offset,
                               length, out_offset, out_valid);
@@ -2291,7 +2291,7 @@ static Status ExecVarWidthCoalesceImpl(KernelContext* ctx, const ExecBatch& batc
       } else {
         const ArrayData& source = *datum.array();
         if (!source.MayHaveNulls() ||
-            BitUtil::GetBit(source.buffers[0]->data(), source.offset + i)) {
+            bit_util::GetBit(source.buffers[0]->data(), source.offset + i)) {
           RETURN_NOT_OK(raw_builder->AppendArraySlice(source, i, /*length=*/1));
           set = true;
           break;
@@ -2476,8 +2476,8 @@ struct CoalesceFunctor<Type, enable_if_union<Type>> {
             const int child_id = type.child_ids()[type_id];
             const ArrayData& child = *source.child_data[child_id];
             if (!child.MayHaveNulls() ||
-                BitUtil::GetBit(child.buffers[0]->data(),
-                                source.offset + child.offset + i)) {
+                bit_util::GetBit(child.buffers[0]->data(),
+                                 source.offset + child.offset + i)) {
               RETURN_NOT_OK(raw_builder->AppendArraySlice(source, i, /*length=*/1));
               set = true;
               break;
@@ -2488,7 +2488,7 @@ struct CoalesceFunctor<Type, enable_if_union<Type>> {
             const int child_id = type.child_ids()[type_id];
             const ArrayData& child = *source.child_data[child_id];
             if (!child.MayHaveNulls() ||
-                BitUtil::GetBit(child.buffers[0]->data(), child.offset + offset)) {
+                bit_util::GetBit(child.buffers[0]->data(), child.offset + offset)) {
               RETURN_NOT_OK(raw_builder->AppendArraySlice(source, i, /*length=*/1));
               set = true;
               break;
@@ -2557,8 +2557,8 @@ Status ExecArrayChoose(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
                   [](const Datum& d) { return d.null_count() > 0; })) {
     out_valid = output->buffers[0]->mutable_data();
   } else {
-    BitUtil::SetBitsTo(output->buffers[0]->mutable_data(), out_offset, batch.length,
-                       true);
+    bit_util::SetBitsTo(output->buffers[0]->mutable_data(), out_offset, batch.length,
+                        true);
   }
   uint8_t* out_values = output->buffers[1]->mutable_data();
   int64_t row = 0;
@@ -2577,7 +2577,7 @@ Status ExecArrayChoose(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
         // Index is null, but we should still initialize the output with some value
         const auto& source = batch.values[1];
         CopyOneValue<Type>(source, row, out_valid, out_values, out_offset + row);
-        BitUtil::ClearBit(out_valid, out_offset + row);
+        bit_util::ClearBit(out_valid, out_offset + row);
         row++;
         return Status::OK();
       });
@@ -2684,7 +2684,7 @@ struct ChooseFunctor<Type, enable_if_base_binary<Type>> {
     }
     const ArrayData& source = *datum.array();
     if (!source.MayHaveNulls() ||
-        BitUtil::GetBit(source.buffers[0]->data(), source.offset + row)) {
+        bit_util::GetBit(source.buffers[0]->data(), source.offset + row)) {
       const uint8_t* data = source.buffers[2]->data();
       const offset_type* offsets = source.GetValues<offset_type>(1);
       const offset_type offset0 = offsets[row];
diff --git a/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc b/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc
index 719a7bf2ffd..5d3233a68b2 100644
--- a/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc
@@ -342,8 +342,8 @@ struct IsInVisitor {
     const auto& state = checked_cast<const SetLookupState<NullType>&>(*ctx->state());
     ArrayData* output = out->mutable_array();
     // skip_nulls is honored for consistency with other types
-    BitUtil::SetBitsTo(output->buffers[1]->mutable_data(), output->offset, output->length,
-                       state.value_set_has_null);
+    bit_util::SetBitsTo(output->buffers[1]->mutable_data(), output->offset,
+                        output->length, state.value_set_has_null);
     return Status::OK();
   }
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_string.cc b/cpp/src/arrow/compute/kernels/scalar_string.cc
index e844218f392..3084753208e 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string.cc
@@ -4516,7 +4516,7 @@ struct BinaryJoinElementWise {
         } else {
           const ArrayData& array = *batch[col].array();
           if (!array.MayHaveNulls() ||
-              BitUtil::GetBit(array.buffers[0]->data(), array.offset + row)) {
+              bit_util::GetBit(array.buffers[0]->data(), array.offset + row)) {
             const offset_type* offsets = array.GetValues<offset_type>(1);
             const uint8_t* data = array.GetValues<uint8_t>(2, /*absolute_offset=*/0);
             const int64_t length = offsets[row + 1] - offsets[row];
@@ -4596,7 +4596,7 @@ struct BinaryJoinElementWise {
       } else {
         const ArrayData& array = *batch[i].array();
         valid = !array.MayHaveNulls() ||
-                BitUtil::GetBit(array.buffers[0]->data(), array.offset + index);
+                bit_util::GetBit(array.buffers[0]->data(), array.offset + index);
         const offset_type* offsets = array.GetValues<offset_type>(1);
         element_size = offsets[index + 1] - offsets[index];
       }
@@ -4952,6 +4952,159 @@ const FunctionDoc utf8_reverse_doc(
      "clusters. Hence, it will not correctly reverse grapheme clusters\n"
      "composed of multiple codepoints."),
     {"strings"});
+
+#ifdef ARROW_WITH_UTF8PROC
+
+struct Utf8NormalizeBase {
+  // Pre-size scratch space
+  explicit Utf8NormalizeBase(const Utf8NormalizeOptions& options)
+      : decompose_options_(MakeDecomposeOptions(options.form)), codepoints_(32) {}
+
+  // Try to decompose the given UTF8 string into the codepoints space,
+  // returning the number of codepoints output.
+  Result<int64_t> DecomposeIntoScratch(util::string_view v) {
+    auto decompose = [&]() {
+      return utf8proc_decompose(reinterpret_cast<const utf8proc_uint8_t*>(v.data()),
+                                v.size(),
+                                reinterpret_cast<utf8proc_int32_t*>(codepoints_.data()),
+                                codepoints_.capacity(), decompose_options_);
+    };
+    auto res = decompose();
+    if (res > static_cast<int64_t>(codepoints_.capacity())) {
+      // Codepoints buffer not large enough, reallocate and try again
+      codepoints_.assign(res, 0);
+      res = decompose();
+      DCHECK_EQ(res, static_cast<int64_t>(codepoints_.capacity()));
+    }
+    if (res < 0) {
+      return Status::Invalid("Cannot normalize utf8 string: ", utf8proc_errmsg(res));
+    }
+    return res;
+  }
+
+  Result<int64_t> Decompose(util::string_view v, BufferBuilder* data_builder) {
+    if (::arrow::util::ValidateAscii(v)) {
+      // Fast path: normalization is a no-op
+      RETURN_NOT_OK(data_builder->Append(v.data(), v.size()));
+      return v.size();
+    }
+    // NOTE: we may be able to find more shortcuts using a precomputed table?
+    // Out of 1114112 valid unicode codepoints, 1097203 don't change when
+    // any normalization is applied.  Precomputing a table of such
+    // "no-op" codepoints would help expand the fast path.
+
+    ARROW_ASSIGN_OR_RAISE(const auto n_codepoints, DecomposeIntoScratch(v));
+    // Encode normalized codepoints directly into the output
+    int64_t n_bytes = 0;
+    for (int64_t i = 0; i < n_codepoints; ++i) {
+      n_bytes += ::arrow::util::UTF8EncodedLength(codepoints_[i]);
+    }
+    RETURN_NOT_OK(data_builder->Reserve(n_bytes));
+    uint8_t* out = data_builder->mutable_data() + data_builder->length();
+    for (int64_t i = 0; i < n_codepoints; ++i) {
+      out = ::arrow::util::UTF8Encode(out, codepoints_[i]);
+    }
+    DCHECK_EQ(out - data_builder->mutable_data(), data_builder->length() + n_bytes);
+    data_builder->UnsafeAdvance(n_bytes);
+    return n_bytes;
+  }
+
+ protected:
+  static utf8proc_option_t MakeDecomposeOptions(Utf8NormalizeOptions::Form form) {
+    switch (form) {
+      case Utf8NormalizeOptions::Form::NFKC:
+        return static_cast<utf8proc_option_t>(UTF8PROC_STABLE | UTF8PROC_COMPOSE |
+                                              UTF8PROC_COMPAT);
+      case Utf8NormalizeOptions::Form::NFD:
+        return static_cast<utf8proc_option_t>(UTF8PROC_STABLE | UTF8PROC_DECOMPOSE);
+      case Utf8NormalizeOptions::Form::NFKD:
+        return static_cast<utf8proc_option_t>(UTF8PROC_STABLE | UTF8PROC_DECOMPOSE |
+                                              UTF8PROC_COMPAT);
+      case Utf8NormalizeOptions::Form::NFC:
+      default:
+        return static_cast<utf8proc_option_t>(UTF8PROC_STABLE | UTF8PROC_COMPOSE);
+    }
+  }
+
+  const utf8proc_option_t decompose_options_;
+  // UTF32 scratch space for decomposition
+  std::vector<uint32_t> codepoints_;
+};
+
+template <typename Type>
+struct Utf8NormalizeExec : public Utf8NormalizeBase {
+  using State = OptionsWrapper<Utf8NormalizeOptions>;
+  using ScalarType = typename TypeTraits<Type>::ScalarType;
+  using offset_type = typename Type::offset_type;
+  using OffsetBuilder = TypedBufferBuilder<offset_type>;
+
+  using Utf8NormalizeBase::Utf8NormalizeBase;
+
+  static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+    const auto& options = State::Get(ctx);
+    Utf8NormalizeExec exec{options};
+    if (batch[0].kind() == Datum::ARRAY) {
+      return exec.ExecArray(ctx, *batch[0].array(), out);
+    } else {
+      DCHECK_EQ(batch[0].kind(), Datum::SCALAR);
+      return exec.ExecScalar(ctx, *batch[0].scalar(), out);
+    }
+  }
+
+  Status ExecArray(KernelContext* ctx, const ArrayData& array, Datum* out) {
+    BufferBuilder data_builder(ctx->memory_pool());
+
+    const offset_type* in_offsets = array.GetValues<offset_type>(1);
+    if (array.length > 0) {
+      RETURN_NOT_OK(data_builder.Reserve(in_offsets[array.length] - in_offsets[0]));
+    }
+    // Output offsets are preallocated
+    offset_type* out_offsets = out->mutable_array()->GetMutableValues<offset_type>(1);
+
+    int64_t offset = 0;
+    *out_offsets++ = static_cast<offset_type>(offset);
+
+    RETURN_NOT_OK(VisitArrayDataInline<Type>(
+        array,
+        [&](util::string_view v) {
+          ARROW_ASSIGN_OR_RAISE(auto n_bytes, Decompose(v, &data_builder));
+          offset += n_bytes;
+          *out_offsets++ = static_cast<offset_type>(offset);
+          return Status::OK();
+        },
+        [&]() {
+          *out_offsets++ = static_cast<offset_type>(offset);
+          return Status::OK();
+        }));
+
+    ArrayData* output = out->mutable_array();
+    RETURN_NOT_OK(data_builder.Finish(&output->buffers[2]));
+    return Status::OK();
+  }
+
+  Status ExecScalar(KernelContext* ctx, const Scalar& scalar, Datum* out) {
+    if (scalar.is_valid) {
+      const auto& string_scalar = checked_cast<const ScalarType&>(scalar);
+      auto* out_scalar = checked_cast<ScalarType*>(out->scalar().get());
+
+      BufferBuilder data_builder(ctx->memory_pool());
+      RETURN_NOT_OK(Decompose(string_scalar.view(), &data_builder));
+      RETURN_NOT_OK(data_builder.Finish(&out_scalar->value));
+      out_scalar->is_valid = true;
+    }
+    return Status::OK();
+  }
+};
+
+const FunctionDoc utf8_normalize_doc(
+    "Utf8-normalize input",
+    ("For each string in `strings`, return the normal form.\n\n"
+     "The normalization form must be given in the options.\n"
+     "Null inputs emit null."),
+    {"strings"}, "Utf8NormalizeOptions");
+
+#endif  // ARROW_WITH_UTF8PROC
+
 }  // namespace
 
 void RegisterScalarStringAscii(FunctionRegistry* registry) {
@@ -5038,6 +5191,9 @@ void RegisterScalarStringAscii(FunctionRegistry* registry) {
   AddUnaryStringPredicate<IsSpaceUnicode>("utf8_is_space", registry, &utf8_is_space_doc);
   AddUnaryStringPredicate<IsTitleUnicode>("utf8_is_title", registry, &utf8_is_title_doc);
   AddUnaryStringPredicate<IsUpperUnicode>("utf8_is_upper", registry, &utf8_is_upper_doc);
+
+  MakeUnaryStringBatchKernelWithState<Utf8NormalizeExec>("utf8_normalize", registry,
+                                                         &utf8_normalize_doc);
 #endif
 
   AddBinaryLength(registry);
diff --git a/cpp/src/arrow/compute/kernels/scalar_string_test.cc b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
index 18ca794f669..fd67e6c4d33 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_test.cc
@@ -930,6 +930,81 @@ TYPED_TEST(TestStringKernels, Utf8Reverse) {
   ASSERT_TRUE(res->array()->buffers[1]->Equals(*malformed_input->data()->buffers[1]));
 }
 
+#ifdef ARROW_WITH_UTF8PROC
+
+TYPED_TEST(TestStringKernels, Utf8Normalize) {
+  Utf8NormalizeOptions nfc_options{Utf8NormalizeOptions::NFC};
+  Utf8NormalizeOptions nfkc_options{Utf8NormalizeOptions::NFKC};
+  Utf8NormalizeOptions nfd_options{Utf8NormalizeOptions::NFD};
+  Utf8NormalizeOptions nfkd_options{Utf8NormalizeOptions::NFKD};
+
+  std::vector<Utf8NormalizeOptions> all_options{nfc_options, nfkc_options, nfd_options,
+                                                nfkd_options};
+  std::vector<Utf8NormalizeOptions> compose_options{nfc_options, nfkc_options};
+  std::vector<Utf8NormalizeOptions> decompose_options{nfd_options, nfkd_options};
+  std::vector<Utf8NormalizeOptions> canonical_options{nfc_options, nfd_options};
+  std::vector<Utf8NormalizeOptions> compatibility_options{nfkc_options, nfkd_options};
+
+  for (const auto& options : all_options) {
+    this->CheckUnary("utf8_normalize", "[]", this->type(), "[]", &options);
+    const char* json_data = R"([null, "", "abc"])";
+    this->CheckUnary("utf8_normalize", json_data, this->type(), json_data, &options);
+  }
+
+  // decomposed: U+0061(LATIN SMALL LETTER A) + U+0301(COMBINING ACUTE ACCENT)
+  // composed: U+00E1(LATIN SMALL LETTER A WITH ACUTE)
+  const char* json_composed = "[\"foo\", \"á\"]";
+  const char* json_decomposed = "[\"foo\", \"a\xcc\x81\"]";
+  for (const auto& options : compose_options) {
+    this->CheckUnary("utf8_normalize", json_decomposed, this->type(), json_composed,
+                     &options);
+    this->CheckUnary("utf8_normalize", json_composed, this->type(), json_composed,
+                     &options);
+  }
+  for (const auto& options : decompose_options) {
+    this->CheckUnary("utf8_normalize", json_composed, this->type(), json_decomposed,
+                     &options);
+    this->CheckUnary("utf8_normalize", json_decomposed, this->type(), json_decomposed,
+                     &options);
+  }
+
+  // canonical: U+00B2(Superscript Two)
+  // compatibility: "2"
+  const char* json_canonical = "[\"01\xc2\xb2!\"]";
+  const char* json_compatibility = "[\"012!\"]";
+  for (const auto& options : canonical_options) {
+    this->CheckUnary("utf8_normalize", json_canonical, this->type(), json_canonical,
+                     &options);
+    this->CheckUnary("utf8_normalize", json_compatibility, this->type(),
+                     json_compatibility, &options);
+  }
+  for (const auto& options : compatibility_options) {
+    this->CheckUnary("utf8_normalize", json_canonical, this->type(), json_compatibility,
+                     &options);
+    this->CheckUnary("utf8_normalize", json_compatibility, this->type(),
+                     json_compatibility, &options);
+  }
+
+  // canonical: U+FDFA(Arabic Ligature Sallallahou Alayhe Wasallam)
+  // compatibility: <18 codepoints>
+  json_canonical = "[\"\xef\xb7\xba\"]";
+  json_compatibility = "[\"صلى الله عليه وسلم\"]";
+  for (const auto& options : canonical_options) {
+    this->CheckUnary("utf8_normalize", json_canonical, this->type(), json_canonical,
+                     &options);
+    this->CheckUnary("utf8_normalize", json_compatibility, this->type(),
+                     json_compatibility, &options);
+  }
+  for (const auto& options : compatibility_options) {
+    this->CheckUnary("utf8_normalize", json_canonical, this->type(), json_compatibility,
+                     &options);
+    this->CheckUnary("utf8_normalize", json_compatibility, this->type(),
+                     json_compatibility, &options);
+  }
+}
+
+#endif
+
 TEST(TestStringKernels, LARGE_MEMORY_TEST(Utf8Upper32bitGrowth)) {
   // 0x7fff * 0xffff is the max a 32 bit string array can hold
   // since the utf8_upper kernel can grow it by 3/2, the max we should accept is is
@@ -1539,6 +1614,7 @@ TYPED_TEST(TestStringKernels, SplitWhitespaceAsciiReverse) {
                    &options_max);
 }
 
+#ifdef ARROW_WITH_UTF8PROC
 TYPED_TEST(TestStringKernels, SplitWhitespaceUTF8) {
   SplitOptions options;
   SplitOptions options_max{1};
@@ -1563,6 +1639,7 @@ TYPED_TEST(TestStringKernels, SplitWhitespaceUTF8Reverse) {
                    "[[\"foo\", \"bar\"], [\"foo\xe2\x80\x88  bar\", \"ba\"]]",
                    &options_max);
 }
+#endif
 
 #ifdef ARROW_WITH_RE2
 TYPED_TEST(TestBaseBinaryKernels, SplitRegex) {
diff --git a/cpp/src/arrow/compute/kernels/scalar_validity.cc b/cpp/src/arrow/compute/kernels/scalar_validity.cc
index b4438a48e78..e32f73ce56f 100644
--- a/cpp/src/arrow/compute/kernels/scalar_validity.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_validity.cc
@@ -47,16 +47,17 @@ struct IsValidOperator {
       // and set the offset to the remaining bit offset.
       out->offset = arr.offset % 8;
       out->buffers[1] =
-          arr.offset == 0 ? arr.buffers[0]
-                          : SliceBuffer(arr.buffers[0], arr.offset / 8,
-                                        BitUtil::BytesForBits(out->length + out->offset));
+          arr.offset == 0
+              ? arr.buffers[0]
+              : SliceBuffer(arr.buffers[0], arr.offset / 8,
+                            bit_util::BytesForBits(out->length + out->offset));
       return Status::OK();
     }
 
     // Input has no nulls => output is entirely true.
     ARROW_ASSIGN_OR_RAISE(out->buffers[1],
                           ctx->AllocateBitmap(out->length + out->offset));
-    BitUtil::SetBitsTo(out->buffers[1]->mutable_data(), out->offset, out->length, true);
+    bit_util::SetBitsTo(out->buffers[1]->mutable_data(), out->offset, out->length, true);
     return Status::OK();
   }
 };
@@ -110,7 +111,7 @@ struct IsNullOperator {
     const T* data = arr.GetValues<T>(1);
     for (int64_t i = 0; i < arr.length; ++i) {
       if (std::isnan(data[i])) {
-        BitUtil::SetBit(out_bitmap, i + out_offset);
+        bit_util::SetBit(out_bitmap, i + out_offset);
       }
     }
   }
@@ -125,7 +126,7 @@ struct IsNullOperator {
                    out->offset);
     } else {
       // Input has no nulls => output is entirely false.
-      BitUtil::SetBitsTo(out_bitmap, out->offset, out->length, false);
+      bit_util::SetBitsTo(out_bitmap, out->offset, out->length, false);
     }
 
     if (is_floating(arr.type->id()) && options.nan_is_null) {
@@ -183,8 +184,8 @@ Status ConstBoolExec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
     return Status::OK();
   }
   ArrayData* array = out->mutable_array();
-  BitUtil::SetBitsTo(array->buffers[1]->mutable_data(), array->offset, array->length,
-                     kConstant);
+  bit_util::SetBitsTo(array->buffers[1]->mutable_data(), array->offset, array->length,
+                      kConstant);
   return Status::OK();
 }
 
@@ -271,8 +272,8 @@ Status IsNullExec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
     } else {
       // Data is preallocated
       ArrayData* out_arr = out->mutable_array();
-      BitUtil::SetBitsTo(out_arr->buffers[1]->mutable_data(), out_arr->offset,
-                         out_arr->length, true);
+      bit_util::SetBitsTo(out_arr->buffers[1]->mutable_data(), out_arr->offset,
+                          out_arr->length, true);
     }
     return Status::OK();
   } else {
diff --git a/cpp/src/arrow/compute/kernels/vector_array_sort.cc b/cpp/src/arrow/compute/kernels/vector_array_sort.cc
index 64cc1fe180b..30692c3d495 100644
--- a/cpp/src/arrow/compute/kernels/vector_array_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_array_sort.cc
@@ -125,7 +125,7 @@ inline void VisitRawValuesInline(const BooleanArray& values,
     const uint8_t* data = values.data()->GetValues<uint8_t>(1, 0);
     VisitBitBlocksVoid(
         values.null_bitmap(), values.offset(), values.length(),
-        [&](int64_t i) { visitor_not_null(BitUtil::GetBit(data, values.offset() + i)); },
+        [&](int64_t i) { visitor_not_null(bit_util::GetBit(data, values.offset() + i)); },
         [&]() { visitor_null(); });
   } else {
     // Can avoid GetBit() overhead in the no-nulls case
diff --git a/cpp/src/arrow/compute/kernels/vector_nested.cc b/cpp/src/arrow/compute/kernels/vector_nested.cc
index fb1087aa5f7..047101869dd 100644
--- a/cpp/src/arrow/compute/kernels/vector_nested.cc
+++ b/cpp/src/arrow/compute/kernels/vector_nested.cc
@@ -85,7 +85,7 @@ struct ListParentIndicesArray {
     auto* out_indices = reinterpret_cast<offset_type*>(indices->mutable_data());
     const auto* bitmap = input->GetValues<uint8_t>(0, 0);
     for (int32_t i = 0; i < input->length; i++) {
-      if (!bitmap || BitUtil::GetBit(bitmap, input->offset + i)) {
+      if (!bitmap || bit_util::GetBit(bitmap, input->offset + i)) {
         std::fill(out_indices, out_indices + slot_length,
                   static_cast<int32_t>(base_output_offset + i));
         out_indices += slot_length;
diff --git a/cpp/src/arrow/compute/kernels/vector_replace.cc b/cpp/src/arrow/compute/kernels/vector_replace.cc
index 93caddf864a..63d0ed94b56 100644
--- a/cpp/src/arrow/compute/kernels/vector_replace.cc
+++ b/cpp/src/arrow/compute/kernels/vector_replace.cc
@@ -58,13 +58,13 @@ Status ReplaceWithScalarMask(KernelContext* ctx, const ArrayData& array,
       arrow::internal::CopyBitmap(in_data.buffers[0]->data(), in_data.offset,
                                   array.length, out_bitmap, out_offset);
     } else {
-      BitUtil::SetBitsTo(out_bitmap, out_offset, array.length, true);
+      bit_util::SetBitsTo(out_bitmap, out_offset, array.length, true);
     }
   } else {
     const Scalar& in_data = *source.scalar();
     Functor::CopyData(*array.type, out_values, out_offset, in_data, /*in_offset=*/0,
                       array.length);
-    BitUtil::SetBitsTo(out_bitmap, out_offset, array.length, in_data.is_valid);
+    bit_util::SetBitsTo(out_bitmap, out_offset, array.length, in_data.is_valid);
   }
   return Status::OK();
 }
@@ -80,8 +80,9 @@ struct CopyArrayBitmap {
   }
 
   void SetBit(uint8_t* out_bitmap, int64_t out_offset, int64_t offset) const {
-    BitUtil::SetBitTo(out_bitmap, out_offset,
-                      in_bitmap ? BitUtil::GetBit(in_bitmap, in_offset + offset) : true);
+    bit_util::SetBitTo(
+        out_bitmap, out_offset,
+        in_bitmap ? bit_util::GetBit(in_bitmap, in_offset + offset) : true);
   }
 };
 
@@ -90,11 +91,11 @@ struct CopyScalarBitmap {
 
   void CopyBitmap(uint8_t* out_bitmap, int64_t out_offset, int64_t offset,
                   int64_t length) const {
-    BitUtil::SetBitsTo(out_bitmap, out_offset, length, is_valid);
+    bit_util::SetBitsTo(out_bitmap, out_offset, length, is_valid);
   }
 
   void SetBit(uint8_t* out_bitmap, int64_t out_offset, int64_t offset) const {
-    BitUtil::SetBitTo(out_bitmap, out_offset, is_valid);
+    bit_util::SetBitTo(out_bitmap, out_offset, is_valid);
   }
 };
 
@@ -123,14 +124,14 @@ void ReplaceWithArrayMaskImpl(const ArrayData& array, const ArrayData& mask,
         copy_bitmap.CopyBitmap(out_bitmap, out_offset + write_offset, replacements_offset,
                                block.length);
       } else if (out_bitmap) {
-        BitUtil::SetBitsTo(out_bitmap, out_offset + write_offset, block.length, true);
+        bit_util::SetBitsTo(out_bitmap, out_offset + write_offset, block.length, true);
       }
       replacements_offset += block.length;
     } else if (block.popcount) {
       for (int64_t i = 0; i < block.length; ++i) {
-        if (BitUtil::GetBit(mask_values, write_offset + mask.offset + i) &&
+        if (bit_util::GetBit(mask_values, write_offset + mask.offset + i) &&
             (!mask_bitmap ||
-             BitUtil::GetBit(mask_bitmap, write_offset + mask.offset + i))) {
+             bit_util::GetBit(mask_bitmap, write_offset + mask.offset + i))) {
           Functor::CopyData(*array.type, out_values, out_offset + write_offset + i,
                             replacements, replacements_offset, /*length=*/1);
           copy_bitmap.SetBit(out_bitmap, out_offset + write_offset + i,
@@ -175,11 +176,11 @@ Status ReplaceWithArrayMask(KernelContext* ctx, const ArrayData& array,
                                   out_bitmap, out_offset);
     } else {
       // Array has no bitmap but mask/replacements do, generate an all-valid bitmap
-      BitUtil::SetBitsTo(out_bitmap, out_offset, array.length, true);
+      bit_util::SetBitsTo(out_bitmap, out_offset, array.length, true);
     }
   } else {
-    BitUtil::SetBitsTo(output->buffers[0]->mutable_data(), out_offset, array.length,
-                       true);
+    bit_util::SetBitsTo(output->buffers[0]->mutable_data(), out_offset, array.length,
+                        true);
     output->null_count = 0;
   }
 
@@ -252,7 +253,7 @@ struct ReplaceWithMask<Type, enable_if_boolean<Type>> {
   }
   static void CopyData(const DataType&, uint8_t* out, const int64_t out_offset,
                        const Scalar& in, const int64_t in_offset, const int64_t length) {
-    BitUtil::SetBitsTo(
+    bit_util::SetBitsTo(
         out, out_offset, length,
         in.is_valid ? checked_cast<const BooleanScalar&>(in).value : false);
   }
@@ -384,7 +385,7 @@ struct ReplaceWithMask<Type, enable_if_base_binary<Type>> {
             const ArrayData& source = replace ? *replacements.array() : array;
             const int64_t offset = replace ? replacements_offset++ : source_offset;
             if (!source.MayHaveNulls() ||
-                BitUtil::GetBit(source.buffers[0]->data(), source.offset + offset)) {
+                bit_util::GetBit(source.buffers[0]->data(), source.offset + offset)) {
               const uint8_t* data = source.buffers[2]->data();
               const offset_type* offsets = source.GetValues<offset_type>(1);
               const offset_type offset0 = offsets[offset];
diff --git a/cpp/src/arrow/compute/kernels/vector_selection.cc b/cpp/src/arrow/compute/kernels/vector_selection.cc
index ba8238ddc9a..14403bcf85f 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection.cc
@@ -142,8 +142,8 @@ Result<std::shared_ptr<ArrayData>> GetTakeIndicesImpl(
       } else {
         // Some of the values are false or null
         for (int64_t i = 0; i < selected_or_null_block.length; ++i) {
-          if (BitUtil::GetBit(filter_is_valid, position_with_offset)) {
-            if (BitUtil::GetBit(filter_data, position_with_offset)) {
+          if (bit_util::GetBit(filter_is_valid, position_with_offset)) {
+            if (bit_util::GetBit(filter_data, position_with_offset)) {
               builder.UnsafeAppend(position);
             }
           } else {
@@ -187,8 +187,8 @@ Result<std::shared_ptr<ArrayData>> GetTakeIndicesImpl(
       } else if (!and_block.NoneSet()) {
         // Some of the values are false or null
         for (int64_t i = 0; i < and_block.length; ++i) {
-          if (BitUtil::GetBit(filter_is_valid, position_with_offset) &&
-              BitUtil::GetBit(filter_data, position_with_offset)) {
+          if (bit_util::GetBit(filter_is_valid, position_with_offset) &&
+              bit_util::GetBit(filter_data, position_with_offset)) {
             builder.UnsafeAppend(position);
           }
           ++position;
@@ -291,7 +291,7 @@ struct PrimitiveTakeImpl {
     // out validity bitmap so that we don't have to use ClearBit in each
     // iteration for nulls.
     if (values.null_count != 0 || indices.null_count != 0) {
-      BitUtil::SetBitsTo(out_is_valid, out_offset, indices.length, false);
+      bit_util::SetBitsTo(out_is_valid, out_offset, indices.length, false);
     }
 
     OptionalBitBlockCounter indices_bit_counter(indices_is_valid, indices_offset,
@@ -305,7 +305,7 @@ struct PrimitiveTakeImpl {
         valid_count += block.popcount;
         if (block.popcount == block.length) {
           // Fastest path: neither values nor index nulls
-          BitUtil::SetBitsTo(out_is_valid, out_offset + position, block.length, true);
+          bit_util::SetBitsTo(out_is_valid, out_offset + position, block.length, true);
           for (int64_t i = 0; i < block.length; ++i) {
             out[position] = values_data[indices_data[position]];
             ++position;
@@ -313,9 +313,9 @@ struct PrimitiveTakeImpl {
         } else if (block.popcount > 0) {
           // Slow path: some indices but not all are null
           for (int64_t i = 0; i < block.length; ++i) {
-            if (BitUtil::GetBit(indices_is_valid, indices_offset + position)) {
+            if (bit_util::GetBit(indices_is_valid, indices_offset + position)) {
               // index is not null
-              BitUtil::SetBit(out_is_valid, out_offset + position);
+              bit_util::SetBit(out_is_valid, out_offset + position);
               out[position] = values_data[indices_data[position]];
             } else {
               out[position] = ValueCType{};
@@ -331,11 +331,11 @@ struct PrimitiveTakeImpl {
         if (block.popcount == block.length) {
           // Faster path: indices are not null but values may be
           for (int64_t i = 0; i < block.length; ++i) {
-            if (BitUtil::GetBit(values_is_valid,
-                                values_offset + indices_data[position])) {
+            if (bit_util::GetBit(values_is_valid,
+                                 values_offset + indices_data[position])) {
               // value is not null
               out[position] = values_data[indices_data[position]];
-              BitUtil::SetBit(out_is_valid, out_offset + position);
+              bit_util::SetBit(out_is_valid, out_offset + position);
               ++valid_count;
             } else {
               out[position] = ValueCType{};
@@ -347,12 +347,12 @@ struct PrimitiveTakeImpl {
           // random access in general we have to check the value nullness one by
           // one.
           for (int64_t i = 0; i < block.length; ++i) {
-            if (BitUtil::GetBit(indices_is_valid, indices_offset + position) &&
-                BitUtil::GetBit(values_is_valid,
-                                values_offset + indices_data[position])) {
+            if (bit_util::GetBit(indices_is_valid, indices_offset + position) &&
+                bit_util::GetBit(values_is_valid,
+                                 values_offset + indices_data[position])) {
               // index is not null && value is not null
               out[position] = values_data[indices_data[position]];
-              BitUtil::SetBit(out_is_valid, out_offset + position);
+              bit_util::SetBit(out_is_valid, out_offset + position);
               ++valid_count;
             } else {
               out[position] = ValueCType{};
@@ -389,14 +389,14 @@ struct BooleanTakeImpl {
     // out validity bitmap so that we don't have to use ClearBit in each
     // iteration for nulls.
     if (values.null_count != 0 || indices.null_count != 0) {
-      BitUtil::SetBitsTo(out_is_valid, out_offset, indices.length, false);
+      bit_util::SetBitsTo(out_is_valid, out_offset, indices.length, false);
     }
     // Avoid uninitialized data in values array
-    BitUtil::SetBitsTo(out, out_offset, indices.length, false);
+    bit_util::SetBitsTo(out, out_offset, indices.length, false);
 
     auto PlaceDataBit = [&](int64_t loc, IndexCType index) {
-      BitUtil::SetBitTo(out, out_offset + loc,
-                        BitUtil::GetBit(values_data, values_offset + index));
+      bit_util::SetBitTo(out, out_offset + loc,
+                         bit_util::GetBit(values_data, values_offset + index));
     };
 
     OptionalBitBlockCounter indices_bit_counter(indices_is_valid, indices_offset,
@@ -410,7 +410,7 @@ struct BooleanTakeImpl {
         valid_count += block.popcount;
         if (block.popcount == block.length) {
           // Fastest path: neither values nor index nulls
-          BitUtil::SetBitsTo(out_is_valid, out_offset + position, block.length, true);
+          bit_util::SetBitsTo(out_is_valid, out_offset + position, block.length, true);
           for (int64_t i = 0; i < block.length; ++i) {
             PlaceDataBit(position, indices_data[position]);
             ++position;
@@ -418,9 +418,9 @@ struct BooleanTakeImpl {
         } else if (block.popcount > 0) {
           // Slow path: some but not all indices are null
           for (int64_t i = 0; i < block.length; ++i) {
-            if (BitUtil::GetBit(indices_is_valid, indices_offset + position)) {
+            if (bit_util::GetBit(indices_is_valid, indices_offset + position)) {
               // index is not null
-              BitUtil::SetBit(out_is_valid, out_offset + position);
+              bit_util::SetBit(out_is_valid, out_offset + position);
               PlaceDataBit(position, indices_data[position]);
             }
             ++position;
@@ -433,10 +433,10 @@ struct BooleanTakeImpl {
         if (block.popcount == block.length) {
           // Faster path: indices are not null but values may be
           for (int64_t i = 0; i < block.length; ++i) {
-            if (BitUtil::GetBit(values_is_valid,
-                                values_offset + indices_data[position])) {
+            if (bit_util::GetBit(values_is_valid,
+                                 values_offset + indices_data[position])) {
               // value is not null
-              BitUtil::SetBit(out_is_valid, out_offset + position);
+              bit_util::SetBit(out_is_valid, out_offset + position);
               PlaceDataBit(position, indices_data[position]);
               ++valid_count;
             }
@@ -447,13 +447,13 @@ struct BooleanTakeImpl {
           // random access in general we have to check the value nullness one by
           // one.
           for (int64_t i = 0; i < block.length; ++i) {
-            if (BitUtil::GetBit(indices_is_valid, indices_offset + position)) {
+            if (bit_util::GetBit(indices_is_valid, indices_offset + position)) {
               // index is not null
-              if (BitUtil::GetBit(values_is_valid,
-                                  values_offset + indices_data[position])) {
+              if (bit_util::GetBit(values_is_valid,
+                                   values_offset + indices_data[position])) {
                 // value is not null
                 PlaceDataBit(position, indices_data[position]);
-                BitUtil::SetBit(out_is_valid, out_offset + position);
+                bit_util::SetBit(out_is_valid, out_offset + position);
                 ++valid_count;
               }
             }
@@ -617,14 +617,14 @@ class PrimitiveFilterImpl {
                                                  values_length_);
 
     auto WriteNotNull = [&](int64_t index) {
-      BitUtil::SetBit(out_is_valid_, out_offset_ + out_position_);
+      bit_util::SetBit(out_is_valid_, out_offset_ + out_position_);
       // Increments out_position_
       WriteValue(index);
     };
 
     auto WriteMaybeNull = [&](int64_t index) {
-      BitUtil::SetBitTo(out_is_valid_, out_offset_ + out_position_,
-                        BitUtil::GetBit(values_is_valid_, values_offset_ + index));
+      bit_util::SetBitTo(out_is_valid_, out_offset_ + out_position_,
+                         bit_util::GetBit(values_is_valid_, values_offset_ + index));
       // Increments out_position_
       WriteValue(index);
     };
@@ -636,8 +636,8 @@ class PrimitiveFilterImpl {
       BitBlockCount data_block = data_counter.NextWord();
       if (filter_block.AllSet() && data_block.AllSet()) {
         // Fastest path: all values in block are included and not null
-        BitUtil::SetBitsTo(out_is_valid_, out_offset_ + out_position_,
-                           filter_block.length, true);
+        bit_util::SetBitsTo(out_is_valid_, out_offset_ + out_position_,
+                            filter_block.length, true);
         WriteValueSegment(in_position, filter_block.length);
         in_position += filter_block.length;
       } else if (filter_block.AllSet()) {
@@ -658,7 +658,7 @@ class PrimitiveFilterImpl {
           if (filter_valid_block.AllSet()) {
             // Filter is non-null but some values are false
             for (int64_t i = 0; i < filter_block.length; ++i) {
-              if (BitUtil::GetBit(filter_data_, filter_offset_ + in_position)) {
+              if (bit_util::GetBit(filter_data_, filter_offset_ + in_position)) {
                 WriteNotNull(in_position);
               }
               ++in_position;
@@ -666,8 +666,8 @@ class PrimitiveFilterImpl {
           } else if (null_selection_ == FilterOptions::DROP) {
             // If any values are selected, they ARE NOT null
             for (int64_t i = 0; i < filter_block.length; ++i) {
-              if (BitUtil::GetBit(filter_is_valid_, filter_offset_ + in_position) &&
-                  BitUtil::GetBit(filter_data_, filter_offset_ + in_position)) {
+              if (bit_util::GetBit(filter_is_valid_, filter_offset_ + in_position) &&
+                  bit_util::GetBit(filter_data_, filter_offset_ + in_position)) {
                 WriteNotNull(in_position);
               }
               ++in_position;
@@ -676,14 +676,14 @@ class PrimitiveFilterImpl {
             // Data values in this block are not null
             for (int64_t i = 0; i < filter_block.length; ++i) {
               const bool is_valid =
-                  BitUtil::GetBit(filter_is_valid_, filter_offset_ + in_position);
+                  bit_util::GetBit(filter_is_valid_, filter_offset_ + in_position);
               if (is_valid &&
-                  BitUtil::GetBit(filter_data_, filter_offset_ + in_position)) {
+                  bit_util::GetBit(filter_data_, filter_offset_ + in_position)) {
                 // Filter slot is non-null and set
                 WriteNotNull(in_position);
               } else if (!is_valid) {
                 // Filter slot is null, so we have a null in the output
-                BitUtil::ClearBit(out_is_valid_, out_offset_ + out_position_);
+                bit_util::ClearBit(out_is_valid_, out_offset_ + out_position_);
                 WriteNull();
               }
               ++in_position;
@@ -694,7 +694,7 @@ class PrimitiveFilterImpl {
           if (filter_valid_block.AllSet()) {
             // Filter is non-null but some values are false
             for (int64_t i = 0; i < filter_block.length; ++i) {
-              if (BitUtil::GetBit(filter_data_, filter_offset_ + in_position)) {
+              if (bit_util::GetBit(filter_data_, filter_offset_ + in_position)) {
                 WriteMaybeNull(in_position);
               }
               ++in_position;
@@ -702,8 +702,8 @@ class PrimitiveFilterImpl {
           } else if (null_selection_ == FilterOptions::DROP) {
             // If any values are selected, they ARE NOT null
             for (int64_t i = 0; i < filter_block.length; ++i) {
-              if (BitUtil::GetBit(filter_is_valid_, filter_offset_ + in_position) &&
-                  BitUtil::GetBit(filter_data_, filter_offset_ + in_position)) {
+              if (bit_util::GetBit(filter_is_valid_, filter_offset_ + in_position) &&
+                  bit_util::GetBit(filter_data_, filter_offset_ + in_position)) {
                 WriteMaybeNull(in_position);
               }
               ++in_position;
@@ -712,14 +712,14 @@ class PrimitiveFilterImpl {
             // Data values in this block are not null
             for (int64_t i = 0; i < filter_block.length; ++i) {
               const bool is_valid =
-                  BitUtil::GetBit(filter_is_valid_, filter_offset_ + in_position);
+                  bit_util::GetBit(filter_is_valid_, filter_offset_ + in_position);
               if (is_valid &&
-                  BitUtil::GetBit(filter_data_, filter_offset_ + in_position)) {
+                  bit_util::GetBit(filter_data_, filter_offset_ + in_position)) {
                 // Filter slot is non-null and set
                 WriteMaybeNull(in_position);
               } else if (!is_valid) {
                 // Filter slot is null, so we have a null in the output
-                BitUtil::ClearBit(out_is_valid_, out_offset_ + out_position_);
+                bit_util::ClearBit(out_is_valid_, out_offset_ + out_position_);
                 WriteNull();
               }
               ++in_position;
@@ -766,8 +766,8 @@ class PrimitiveFilterImpl {
 
 template <>
 inline void PrimitiveFilterImpl<BooleanType>::WriteValue(int64_t in_position) {
-  BitUtil::SetBitTo(out_data_, out_offset_ + out_position_++,
-                    BitUtil::GetBit(values_data_, values_offset_ + in_position));
+  bit_util::SetBitTo(out_data_, out_offset_ + out_position_++,
+                     bit_util::GetBit(values_data_, values_offset_ + in_position));
 }
 
 template <>
@@ -781,7 +781,7 @@ inline void PrimitiveFilterImpl<BooleanType>::WriteValueSegment(int64_t in_start
 template <>
 inline void PrimitiveFilterImpl<BooleanType>::WriteNull() {
   // Zero the bit
-  BitUtil::ClearBit(out_data_, out_offset_ + out_position_++);
+  bit_util::ClearBit(out_data_, out_offset_ + out_position_++);
 }
 
 Status PrimitiveFilter(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
@@ -922,7 +922,7 @@ Status BinaryFilterImpl(KernelContext* ctx, const ArrayData& values,
 
   uint8_t* out_is_valid = out->buffers[0]->mutable_data();
   // Zero bits and then only have to set valid values to true
-  BitUtil::SetBitsTo(out_is_valid, 0, output_length, false);
+  bit_util::SetBitsTo(out_is_valid, 0, output_length, false);
 
   // We use 3 block counters for fast scanning of the filter
   //
@@ -953,7 +953,7 @@ Status BinaryFilterImpl(KernelContext* ctx, const ArrayData& values,
         // Fastest path: filter values are all true and not null
         if (values_valid_block.AllSet()) {
           // The values aren't null either
-          BitUtil::SetBitsTo(out_is_valid, out_position, filter_block.length, true);
+          bit_util::SetBitsTo(out_is_valid, out_position, filter_block.length, true);
 
           // Bulk-append raw data
           offset_type block_data_bytes =
@@ -970,8 +970,8 @@ Status BinaryFilterImpl(KernelContext* ctx, const ArrayData& values,
           for (int64_t i = 0; i < filter_block.length;
                ++i, ++in_position, ++out_position) {
             offset_builder.UnsafeAppend(offset);
-            if (BitUtil::GetBit(values_is_valid, values_offset + in_position)) {
-              BitUtil::SetBit(out_is_valid, out_position);
+            if (bit_util::GetBit(values_is_valid, values_offset + in_position)) {
+              bit_util::SetBit(out_is_valid, out_position);
               APPEND_SINGLE_VALUE();
             }
           }
@@ -982,9 +982,9 @@ Status BinaryFilterImpl(KernelContext* ctx, const ArrayData& values,
           // All the values are not-null, so we can skip null checking for
           // them
           for (int64_t i = 0; i < filter_block.length; ++i, ++in_position) {
-            if (BitUtil::GetBit(filter_data, filter_offset + in_position)) {
+            if (bit_util::GetBit(filter_data, filter_offset + in_position)) {
               offset_builder.UnsafeAppend(offset);
-              BitUtil::SetBit(out_is_valid, out_position++);
+              bit_util::SetBit(out_is_valid, out_position++);
               APPEND_SINGLE_VALUE();
             }
           }
@@ -992,10 +992,10 @@ Status BinaryFilterImpl(KernelContext* ctx, const ArrayData& values,
           // Some of the values in the block are null, so we have to check
           // each one
           for (int64_t i = 0; i < filter_block.length; ++i, ++in_position) {
-            if (BitUtil::GetBit(filter_data, filter_offset + in_position)) {
+            if (bit_util::GetBit(filter_data, filter_offset + in_position)) {
               offset_builder.UnsafeAppend(offset);
-              if (BitUtil::GetBit(values_is_valid, values_offset + in_position)) {
-                BitUtil::SetBit(out_is_valid, out_position);
+              if (bit_util::GetBit(values_is_valid, values_offset + in_position)) {
+                bit_util::SetBit(out_is_valid, out_position);
                 APPEND_SINGLE_VALUE();
               }
               ++out_position;
@@ -1010,20 +1010,20 @@ Status BinaryFilterImpl(KernelContext* ctx, const ArrayData& values,
         // Filter null values are treated as false.
         if (values_valid_block.AllSet()) {
           for (int64_t i = 0; i < filter_block.length; ++i, ++in_position) {
-            if (BitUtil::GetBit(filter_is_valid, filter_offset + in_position) &&
-                BitUtil::GetBit(filter_data, filter_offset + in_position)) {
+            if (bit_util::GetBit(filter_is_valid, filter_offset + in_position) &&
+                bit_util::GetBit(filter_data, filter_offset + in_position)) {
               offset_builder.UnsafeAppend(offset);
-              BitUtil::SetBit(out_is_valid, out_position++);
+              bit_util::SetBit(out_is_valid, out_position++);
               APPEND_SINGLE_VALUE();
             }
           }
         } else {
           for (int64_t i = 0; i < filter_block.length; ++i, ++in_position) {
-            if (BitUtil::GetBit(filter_is_valid, filter_offset + in_position) &&
-                BitUtil::GetBit(filter_data, filter_offset + in_position)) {
+            if (bit_util::GetBit(filter_is_valid, filter_offset + in_position) &&
+                bit_util::GetBit(filter_data, filter_offset + in_position)) {
               offset_builder.UnsafeAppend(offset);
-              if (BitUtil::GetBit(values_is_valid, values_offset + in_position)) {
-                BitUtil::SetBit(out_is_valid, out_position);
+              if (bit_util::GetBit(values_is_valid, values_offset + in_position)) {
+                bit_util::SetBit(out_is_valid, out_position);
                 APPEND_SINGLE_VALUE();
               }
               ++out_position;
@@ -1038,11 +1038,11 @@ Status BinaryFilterImpl(KernelContext* ctx, const ArrayData& values,
         if (values_valid_block.AllSet()) {
           for (int64_t i = 0; i < filter_block.length; ++i, ++in_position) {
             const bool filter_not_null =
-                BitUtil::GetBit(filter_is_valid, filter_offset + in_position);
+                bit_util::GetBit(filter_is_valid, filter_offset + in_position);
             if (filter_not_null &&
-                BitUtil::GetBit(filter_data, filter_offset + in_position)) {
+                bit_util::GetBit(filter_data, filter_offset + in_position)) {
               offset_builder.UnsafeAppend(offset);
-              BitUtil::SetBit(out_is_valid, out_position++);
+              bit_util::SetBit(out_is_valid, out_position++);
               APPEND_SINGLE_VALUE();
             } else if (!filter_not_null) {
               offset_builder.UnsafeAppend(offset);
@@ -1052,12 +1052,12 @@ Status BinaryFilterImpl(KernelContext* ctx, const ArrayData& values,
         } else {
           for (int64_t i = 0; i < filter_block.length; ++i, ++in_position) {
             const bool filter_not_null =
-                BitUtil::GetBit(filter_is_valid, filter_offset + in_position);
+                bit_util::GetBit(filter_is_valid, filter_offset + in_position);
             if (filter_not_null &&
-                BitUtil::GetBit(filter_data, filter_offset + in_position)) {
+                bit_util::GetBit(filter_data, filter_offset + in_position)) {
               offset_builder.UnsafeAppend(offset);
-              if (BitUtil::GetBit(values_is_valid, values_offset + in_position)) {
-                BitUtil::SetBit(out_is_valid, out_position);
+              if (bit_util::GetBit(values_is_valid, values_offset + in_position)) {
+                bit_util::SetBit(out_is_valid, out_position);
                 APPEND_SINGLE_VALUE();
               }
               ++out_position;
@@ -1377,7 +1377,7 @@ struct Selection {
             // All the values are not-null, so we can skip null checking for
             // them
             for (int64_t i = 0; i < filter_block.length; ++i) {
-              if (BitUtil::GetBit(filter_data, filter_offset + in_position)) {
+              if (bit_util::GetBit(filter_data, filter_offset + in_position)) {
                 RETURN_NOT_OK(AppendNotNull(in_position));
               }
               ++in_position;
@@ -1386,7 +1386,7 @@ struct Selection {
             // Some of the values in the block are null, so we have to check
             // each one
             for (int64_t i = 0; i < filter_block.length; ++i) {
-              if (BitUtil::GetBit(filter_data, filter_offset + in_position)) {
+              if (bit_util::GetBit(filter_data, filter_offset + in_position)) {
                 RETURN_NOT_OK(AppendMaybeNull(in_position));
               }
               ++in_position;
@@ -1399,8 +1399,8 @@ struct Selection {
         if (null_selection == FilterOptions::DROP) {
           // Filter null values are treated as false.
           for (int64_t i = 0; i < filter_block.length; ++i) {
-            if (BitUtil::GetBit(filter_is_valid, filter_offset + in_position) &&
-                BitUtil::GetBit(filter_data, filter_offset + in_position)) {
+            if (bit_util::GetBit(filter_is_valid, filter_offset + in_position) &&
+                bit_util::GetBit(filter_data, filter_offset + in_position)) {
               RETURN_NOT_OK(AppendMaybeNull(in_position));
             }
             ++in_position;
@@ -1410,9 +1410,9 @@ struct Selection {
           // value in the corresponding slot is valid or not
           for (int64_t i = 0; i < filter_block.length; ++i) {
             const bool filter_not_null =
-                BitUtil::GetBit(filter_is_valid, filter_offset + in_position);
+                bit_util::GetBit(filter_is_valid, filter_offset + in_position);
             if (filter_not_null &&
-                BitUtil::GetBit(filter_data, filter_offset + in_position)) {
+                bit_util::GetBit(filter_data, filter_offset + in_position)) {
               RETURN_NOT_OK(AppendMaybeNull(in_position));
             } else if (!filter_not_null) {
               // EMIT_NULL case
@@ -2230,10 +2230,10 @@ Result<Datum> DropNullRecordBatch(const std::shared_ptr<RecordBatch>& batch,
   }
   ARROW_ASSIGN_OR_RAISE(auto dst,
                         AllocateEmptyBitmap(batch->num_rows(), ctx->memory_pool()));
-  BitUtil::SetBitsTo(dst->mutable_data(), 0, batch->num_rows(), true);
+  bit_util::SetBitsTo(dst->mutable_data(), 0, batch->num_rows(), true);
   for (const auto& column : batch->columns()) {
     if (column->type()->id() == Type::type::NA) {
-      BitUtil::SetBitsTo(dst->mutable_data(), 0, batch->num_rows(), false);
+      bit_util::SetBitsTo(dst->mutable_data(), 0, batch->num_rows(), false);
       break;
     }
     if (column->null_bitmap_data()) {
diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index 687faa281a6..6b103e250e8 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -1221,7 +1221,7 @@ class SortIndicesMetaFunction : public MetaFunction {
 
     auto out_type = uint64();
     auto length = chunked_array.length();
-    auto buffer_size = BitUtil::BytesForBits(
+    auto buffer_size = bit_util::BytesForBits(
         length * std::static_pointer_cast<UInt64Type>(out_type)->bit_width());
     std::vector<std::shared_ptr<Buffer>> buffers(2);
     ARROW_ASSIGN_OR_RAISE(buffers[1],
@@ -1251,7 +1251,7 @@ class SortIndicesMetaFunction : public MetaFunction {
 
     auto out_type = uint64();
     auto length = batch.num_rows();
-    auto buffer_size = BitUtil::BytesForBits(
+    auto buffer_size = bit_util::BytesForBits(
         length * std::static_pointer_cast<UInt64Type>(out_type)->bit_width());
     BufferVector buffers(2);
     ARROW_ASSIGN_OR_RAISE(buffers[1],
@@ -1291,7 +1291,7 @@ class SortIndicesMetaFunction : public MetaFunction {
 
     auto out_type = uint64();
     auto length = table.num_rows();
-    auto buffer_size = BitUtil::BytesForBits(
+    auto buffer_size = bit_util::BytesForBits(
         length * std::static_pointer_cast<UInt64Type>(out_type)->bit_width());
     std::vector<std::shared_ptr<Buffer>> buffers(2);
     ARROW_ASSIGN_OR_RAISE(buffers[1],
diff --git a/cpp/src/arrow/csv/converter.cc b/cpp/src/arrow/csv/converter.cc
index 4d00cbec4eb..c395c277fd0 100644
--- a/cpp/src/arrow/csv/converter.cc
+++ b/cpp/src/arrow/csv/converter.cc
@@ -195,18 +195,34 @@ struct BinaryValueDecoder : public ValueDecoder {
 // Value decoder for integers, floats and temporals
 //
 
+template <typename T, typename Enable = void>
+struct StringConverterFromOptions {
+  static internal::StringConverter<T> Make(const ConvertOptions&) {
+    return internal::StringConverter<T>{};
+  }
+};
+
+template <typename T>
+struct StringConverterFromOptions<T, enable_if_floating_point<T>> {
+  static internal::StringConverter<T> Make(const ConvertOptions& options) {
+    return internal::StringConverter<T>{options.decimal_point};
+  }
+};
+
 template <typename T>
 struct NumericValueDecoder : public ValueDecoder {
   using value_type = typename T::c_type;
 
-  explicit NumericValueDecoder(const std::shared_ptr<DataType>& type,
-                               const ConvertOptions& options)
-      : ValueDecoder(type, options), concrete_type_(checked_cast<const T&>(*type)) {}
+  NumericValueDecoder(const std::shared_ptr<DataType>& type,
+                      const ConvertOptions& options)
+      : ValueDecoder(type, options),
+        concrete_type_(checked_cast<const T&>(*type)),
+        string_converter_(StringConverterFromOptions<T>::Make(options)) {}
 
   Status Decode(const uint8_t* data, uint32_t size, bool quoted, value_type* out) {
     // XXX should quoted values be allowed at all?
     TrimWhiteSpace(&data, &size);
-    if (ARROW_PREDICT_FALSE(!internal::ParseValue<T>(
+    if (ARROW_PREDICT_FALSE(!string_converter_.Convert(
             concrete_type_, reinterpret_cast<const char*>(data), size, out))) {
       return GenericConversionError(type_, data, size);
     }
@@ -215,6 +231,7 @@ struct NumericValueDecoder : public ValueDecoder {
 
  protected:
   const T& concrete_type_;
+  internal::StringConverter<T> string_converter_;
 };
 
 //
@@ -292,8 +309,7 @@ struct DecimalValueDecoder : public ValueDecoder {
 };
 
 //
-// Value decoder wrapper for floating-point and decimals
-// with a non-default decimal point
+// Value decoder wrapper for decimals with a non-default decimal point
 //
 
 template <typename WrappedDecoder>
@@ -686,8 +702,8 @@ Result<std::shared_ptr<Converter>> Converter::Make(const std::shared_ptr<DataTyp
     NUMERIC_CONVERTER_CASE(Type::UINT16, UInt16Type)
     NUMERIC_CONVERTER_CASE(Type::UINT32, UInt32Type)
     NUMERIC_CONVERTER_CASE(Type::UINT64, UInt64Type)
-    REAL_CONVERTER_CASE(Type::FLOAT, FloatType, NumericValueDecoder<FloatType>)
-    REAL_CONVERTER_CASE(Type::DOUBLE, DoubleType, NumericValueDecoder<DoubleType>)
+    NUMERIC_CONVERTER_CASE(Type::FLOAT, FloatType)
+    NUMERIC_CONVERTER_CASE(Type::DOUBLE, DoubleType)
     REAL_CONVERTER_CASE(Type::DECIMAL, Decimal128Type, DecimalValueDecoder)
     NUMERIC_CONVERTER_CASE(Type::DATE32, Date32Type)
     NUMERIC_CONVERTER_CASE(Type::DATE64, Date64Type)
@@ -774,8 +790,8 @@ Result<std::shared_ptr<DictionaryConverter>> DictionaryConverter::Make(
     CONVERTER_CASE(Type::INT64, Int64Type, NumericValueDecoder<Int64Type>)
     CONVERTER_CASE(Type::UINT32, UInt32Type, NumericValueDecoder<UInt32Type>)
     CONVERTER_CASE(Type::UINT64, UInt64Type, NumericValueDecoder<UInt64Type>)
-    REAL_CONVERTER_CASE(Type::FLOAT, FloatType, NumericValueDecoder<FloatType>)
-    REAL_CONVERTER_CASE(Type::DOUBLE, DoubleType, NumericValueDecoder<DoubleType>)
+    CONVERTER_CASE(Type::FLOAT, FloatType, NumericValueDecoder<FloatType>)
+    CONVERTER_CASE(Type::DOUBLE, DoubleType, NumericValueDecoder<DoubleType>)
     REAL_CONVERTER_CASE(Type::DECIMAL, Decimal128Type, DecimalValueDecoder)
     CONVERTER_CASE(Type::FIXED_SIZE_BINARY, FixedSizeBinaryType,
                    FixedSizeBinaryValueDecoder)
diff --git a/cpp/src/arrow/csv/options.h b/cpp/src/arrow/csv/options.h
index 38514bcb930..d5c69f28e34 100644
--- a/cpp/src/arrow/csv/options.h
+++ b/cpp/src/arrow/csv/options.h
@@ -180,6 +180,9 @@ struct ARROW_EXPORT WriteOptions {
   /// This number can impact performance.
   int32_t batch_size = 1024;
 
+  /// \brief The string to write for null values. Quotes are not allowed in this string.
+  std::string null_string;
+
   /// \brief IO context for writing.
   io::IOContext io_context;
 
diff --git a/cpp/src/arrow/csv/parser.cc b/cpp/src/arrow/csv/parser.cc
index 6400c94bb54..afd5a6f897e 100644
--- a/cpp/src/arrow/csv/parser.cc
+++ b/cpp/src/arrow/csv/parser.cc
@@ -26,6 +26,7 @@
 #include "arrow/result.h"
 #include "arrow/status.h"
 #include "arrow/util/logging.h"
+#include "arrow/util/simd.h"
 
 namespace arrow {
 namespace csv {
@@ -64,6 +65,127 @@ class SpecializedOptions {
   static constexpr bool escaping = Escaping;
 };
 
+//
+// Bulk filters for packed character matching.
+// These filters allow checking multiple CSV bytes at once for specific
+// characters (cell delimiter, line delimiter, escape char, etc.).
+//
+
+// Heuristic Bloom filters: 1, 2 or 4 bytes at a time.
+
+class BaseBloomFilter {
+ public:
+  explicit BaseBloomFilter(const ParseOptions& options) : filter_(MakeFilter(options)) {}
+
+ protected:
+  using FilterType = uint64_t;
+  // 63 for uint64_t
+  static constexpr uint8_t kCharMask = static_cast<uint8_t>((8 * sizeof(FilterType)) - 1);
+
+  FilterType MakeFilter(const ParseOptions& options) {
+    FilterType filter = 0;
+    auto add_char = [&](char c) { filter |= CharFilter(c); };
+    add_char('\n');
+    add_char('\r');
+    add_char(options.delimiter);
+    if (options.escaping) {
+      add_char(options.escape_char);
+    }
+    if (options.quoting) {
+      add_char(options.quote_char);
+    }
+    return filter;
+  }
+
+  // A given character value will set/test one bit in the 64-bit filter,
+  // whose bit number is taken from low bits of the character value.
+  //
+  // For example 'b' (ASCII value 98) will set/test bit #34 in the filter.
+  // If the bit is set in the filter, the given character *may* be part
+  // of the matched characters.  If the bit is unset in the filter,
+  // the the given character *cannot* be part of the matched characters.
+  FilterType CharFilter(uint8_t c) {
+    return static_cast<FilterType>(1) << (c & kCharMask);
+  }
+
+  FilterType MatchChar(uint8_t c) { return CharFilter(c) & filter_; }
+
+  const FilterType filter_;
+};
+
+class BloomFilter1B : public BaseBloomFilter {
+ public:
+  using WordType = uint8_t;
+
+  using BaseBloomFilter::BaseBloomFilter;
+
+  bool Matches(uint8_t c) { return (CharFilter(c) & filter_) != 0; }
+};
+
+class BloomFilter2B : public BaseBloomFilter {
+ public:
+  using WordType = uint16_t;
+
+  using BaseBloomFilter::BaseBloomFilter;
+
+  bool Matches(uint16_t w) {
+    return (MatchChar(static_cast<uint8_t>(w >> 8)) |
+            MatchChar(static_cast<uint8_t>(w))) != 0;
+  }
+};
+
+class BloomFilter4B : public BaseBloomFilter {
+ public:
+  using WordType = uint32_t;
+
+  using BaseBloomFilter::BaseBloomFilter;
+
+  bool Matches(uint32_t w) {
+    return (MatchChar(static_cast<uint8_t>(w >> 24)) |
+            MatchChar(static_cast<uint8_t>(w >> 16)) |
+            MatchChar(static_cast<uint8_t>(w >> 8)) |
+            MatchChar(static_cast<uint8_t>(w))) != 0;
+  }
+};
+
+#ifdef ARROW_HAVE_SSE4_2
+
+// SSE4.2 filter: 8 bytes at a time, using packed compare instruction
+
+// NOTE: on SVE, could use svmatch[_u8] for similar functionality.
+
+class SSE42Filter {
+ public:
+  using WordType = uint64_t;
+
+  explicit SSE42Filter(const ParseOptions& options) : filter_(MakeFilter(options)) {}
+
+  bool Matches(WordType w) {
+    // Look up every byte in `w` in the SIMD filter.
+    return _mm_cmpistrc(_mm_set1_epi64x(w), filter_,
+                        _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY);
+  }
+
+ protected:
+  using BulkFilterType = __m128i;
+
+  BulkFilterType MakeFilter(const ParseOptions& options) {
+    // Make a SIMD word of the characters we want to match
+    const char cr = '\r';
+    const char lf = '\n';
+    const char delim = options.delimiter;
+    const char quote = options.quoting ? options.quote_char : cr;
+    const char escape = options.escaping ? options.escape_char : cr;
+
+    return _mm_set_epi8(delim, quote, escape, lf, cr, cr, cr, cr, cr, cr, cr, cr, cr, cr,
+                        cr, cr);
+  }
+
+  const BulkFilterType filter_;
+};
+
+#endif
+
 // A helper class allocating the buffer for parsed values and writing into it
 // without any further resizes, except at the end.
 class PresizedDataWriter {
@@ -86,6 +208,13 @@ class PresizedDataWriter {
     parsed_[parsed_size_++] = static_cast<uint8_t>(c);
   }
 
+  template <typename Word>
+  void PushFieldWord(Word w) {
+    DCHECK_GE(parsed_capacity_ - parsed_size_, static_cast<int64_t>(sizeof(w)));
+    memcpy(parsed_ + parsed_size_, &w, sizeof(w));
+    parsed_size_ += sizeof(w);
+  }
+
   // Rollback the state that was saved in BeginLine()
   void RollbackLine() { parsed_size_ = saved_parsed_size_; }
 
@@ -181,13 +310,21 @@ class PresizedValueDescWriter : public ValueDescWriter<PresizedValueDescWriter>
 }  // namespace
 
 class BlockParserImpl {
+#if defined(ARROW_HAVE_SSE4_2) && (defined(__x86_64__) || defined(_M_X64))
+  // (the SSE4.2 filter seems to crash on RTools with 32-bit MinGW)
+  using BulkFilterType = SSE42Filter;
+#else
+  using BulkFilterType = BloomFilter4B;
+#endif
+
  public:
   BlockParserImpl(MemoryPool* pool, ParseOptions options, int32_t num_cols,
                   int64_t first_row, int32_t max_num_rows)
       : pool_(pool),
-        options_(options),
+        options_(std::move(options)),
         first_row_(first_row),
         max_num_rows_(max_num_rows),
+        bulk_filter_(options_),
         batch_(num_cols) {}
 
   const DataBatch& parsed_batch() const { return batch_; }
@@ -230,7 +367,8 @@ class BlockParserImpl {
     return MismatchingColumns(row);
   }
 
-  template <typename SpecializedOptions, typename ValueDescWriter, typename DataWriter>
+  template <typename SpecializedOptions, bool UseBulkFilter, typename ValueDescWriter,
+            typename DataWriter>
   Status ParseLine(ValueDescWriter* values_writer, DataWriter* parsed_writer,
                    const char* data, const char* data_end, bool is_final,
                    const char** out_data) {
@@ -265,6 +403,18 @@ class BlockParserImpl {
 
   FieldStart:
     // At the start of a field
+    if (*data == options_.delimiter) {
+      // Empty cells are very common in some files, shortcut them
+      values_writer->StartField(false /* quoted */);
+      FinishField();
+      ++data;
+      ++num_cols;
+      if (ARROW_PREDICT_FALSE(data == data_end)) {
+        goto AbortLine;
+      }
+      goto FieldStart;
+    }
+
     // Quoting is only recognized at start of field
     if (SpecializedOptions::quoting &&
         ARROW_PREDICT_FALSE(*data == options_.quote_char)) {
@@ -278,9 +428,18 @@ class BlockParserImpl {
 
   InField:
     // Inside a non-quoted part of a field
-    if (ARROW_PREDICT_FALSE(data == data_end)) {
-      goto AbortLine;
+    if (UseBulkFilter) {
+      const char* bulk_end = BulkFilter(parsed_writer, data, data_end);
+      if (ARROW_PREDICT_FALSE(bulk_end == nullptr)) {
+        goto AbortLine;
+      }
+      data = bulk_end;
+    } else {
+      if (ARROW_PREDICT_FALSE(data == data_end)) {
+        goto AbortLine;
+      }
     }
+
     c = *data++;
     if (SpecializedOptions::escaping && ARROW_PREDICT_FALSE(c == options_.escape_char)) {
       if (ARROW_PREDICT_FALSE(data == data_end)) {
@@ -310,8 +469,16 @@ class BlockParserImpl {
 
   InQuotedField:
     // Inside a quoted part of a field
-    if (ARROW_PREDICT_FALSE(data == data_end)) {
-      goto AbortLine;
+    if (UseBulkFilter) {
+      const char* bulk_end = BulkFilter(parsed_writer, data, data_end);
+      if (ARROW_PREDICT_FALSE(bulk_end == nullptr)) {
+        goto AbortLine;
+      }
+      data = bulk_end;
+    } else {
+      if (ARROW_PREDICT_FALSE(data == data_end)) {
+        goto AbortLine;
+      }
     }
     c = *data++;
     if (SpecializedOptions::escaping && ARROW_PREDICT_FALSE(c == options_.escape_char)) {
@@ -387,24 +554,72 @@ class BlockParserImpl {
     return Status::OK();
   }
 
+  template <typename DataWriter>
+  const char* BulkFilter(DataWriter* data_writer, const char* data,
+                         const char* data_end) {
+    while (true) {
+      using WordType = BulkFilterType::WordType;
+
+      if (ARROW_PREDICT_FALSE(static_cast<size_t>(data_end - data) < sizeof(WordType))) {
+        if (ARROW_PREDICT_FALSE(data == data_end)) {
+          return nullptr;
+        }
+        return data;
+      }
+      WordType word;
+      memcpy(&word, data, sizeof(WordType));
+      if (bulk_filter_.Matches(word)) {
+        return data;
+      }
+      // No special chars
+      data_writer->PushFieldWord(word);
+      data += sizeof(WordType);
+    }
+  }
+
   template <typename SpecializedOptions, typename ValueDescWriter, typename DataWriter>
   Status ParseChunk(ValueDescWriter* values_writer, DataWriter* parsed_writer,
                     const char* data, const char* data_end, bool is_final,
                     int32_t rows_in_chunk, const char** out_data,
                     bool* finished_parsing) {
-    int32_t num_rows_deadline = batch_.num_rows_ + rows_in_chunk;
-
-    while (data < data_end && batch_.num_rows_ < num_rows_deadline) {
-      const char* line_end = data;
-      RETURN_NOT_OK(ParseLine<SpecializedOptions>(values_writer, parsed_writer, data,
-                                                  data_end, is_final, &line_end));
-      if (line_end == data) {
-        // Cannot parse any further
-        *finished_parsing = true;
-        break;
+    const int32_t start_num_rows = batch_.num_rows_;
+    const int32_t num_rows_deadline = batch_.num_rows_ + rows_in_chunk;
+
+    if (use_bulk_filter_) {
+      while (data < data_end && batch_.num_rows_ < num_rows_deadline) {
+        const char* line_end = data;
+        RETURN_NOT_OK((ParseLine<SpecializedOptions, true>(
+            values_writer, parsed_writer, data, data_end, is_final, &line_end)));
+        if (line_end == data) {
+          // Cannot parse any further
+          *finished_parsing = true;
+          break;
+        }
+        data = line_end;
       }
-      data = line_end;
+    } else {
+      while (data < data_end && batch_.num_rows_ < num_rows_deadline) {
+        const char* line_end = data;
+        RETURN_NOT_OK((ParseLine<SpecializedOptions, false>(
+            values_writer, parsed_writer, data, data_end, is_final, &line_end)));
+        if (line_end == data) {
+          // Cannot parse any further
+          *finished_parsing = true;
+          break;
+        }
+        data = line_end;
+      }
+    }
+
+    if (batch_.num_rows_ > start_num_rows && batch_.num_cols_ > 0) {
+      // Use bulk filter only if average value length is >= 10 bytes,
+      // as the bulk filter has a fixed cost that isn't compensated
+      // when values are too short.
+      const int64_t bulk_filter_threshold =
+          batch_.num_cols_ * (batch_.num_rows_ - start_num_rows) * 10;
+      use_bulk_filter_ = (data - *out_data) > bulk_filter_threshold;
     }
+
     // Append new buffers and update size
     std::shared_ptr<Buffer> values_buffer;
     values_writer->Finish(&values_buffer);
@@ -539,6 +754,9 @@ class BlockParserImpl {
   // The maximum number of rows to parse from a block
   int32_t max_num_rows_;
 
+  BulkFilterType bulk_filter_;
+  bool use_bulk_filter_ = false;
+
   // Unparsed data size
   int32_t values_size_;
   // Parsed data batch
diff --git a/cpp/src/arrow/csv/writer.cc b/cpp/src/arrow/csv/writer.cc
index 1b782cae7dc..3bf72664a90 100644
--- a/cpp/src/arrow/csv/writer.cc
+++ b/cpp/src/arrow/csv/writer.cc
@@ -87,7 +87,8 @@ constexpr int64_t kQuoteDelimiterCount = kQuoteCount + /*end_char*/ 1;
 // populators (it populates data backwards).
 class ColumnPopulator {
  public:
-  ColumnPopulator(MemoryPool* pool, char end_char) : end_char_(end_char), pool_(pool) {}
+  ColumnPopulator(MemoryPool* pool, char end_char, std::shared_ptr<Buffer> null_string)
+      : end_char_(end_char), null_string_(std::move(null_string)), pool_(pool) {}
 
   virtual ~ColumnPopulator() = default;
 
@@ -117,6 +118,7 @@ class ColumnPopulator {
   virtual Status UpdateRowLengths(int32_t* row_lengths) = 0;
   std::shared_ptr<StringArray> casted_array_;
   const char end_char_;
+  std::shared_ptr<Buffer> null_string_;
 
  private:
   MemoryPool* const pool_;
@@ -140,12 +142,15 @@ char* EscapeReverse(arrow::util::string_view s, char* out_end) {
 // from a cast does not require quoting or escaping.
 class UnquotedColumnPopulator : public ColumnPopulator {
  public:
-  explicit UnquotedColumnPopulator(MemoryPool* memory_pool, char end_char)
-      : ColumnPopulator(memory_pool, end_char) {}
+  explicit UnquotedColumnPopulator(MemoryPool* memory_pool, char end_char,
+                                   std::shared_ptr<Buffer> null_string_)
+      : ColumnPopulator(memory_pool, end_char, std::move(null_string_)) {}
 
   Status UpdateRowLengths(int32_t* row_lengths) override {
     for (int x = 0; x < casted_array_->length(); x++) {
-      row_lengths[x] += casted_array_->value_length(x);
+      row_lengths[x] += casted_array_->IsNull(x)
+                            ? static_cast<int32_t>(null_string_->size())
+                            : casted_array_->value_length(x);
     }
     return Status::OK();
   }
@@ -154,16 +159,20 @@ class UnquotedColumnPopulator : public ColumnPopulator {
     VisitArrayDataInline<StringType>(
         *casted_array_->data(),
         [&](arrow::util::string_view s) {
-          int64_t next_column_offset = s.length() + /*end_char*/ 1;
+          int32_t next_column_offset = static_cast<int32_t>(s.length()) + /*end_char*/ 1;
           memcpy((output + *offsets - next_column_offset), s.data(), s.length());
           *(output + *offsets - 1) = end_char_;
-          *offsets -= static_cast<int32_t>(next_column_offset);
+          *offsets -= next_column_offset;
           offsets++;
         },
         [&]() {
-          // Nulls are empty (unquoted) to distinguish with empty string.
+          // For nulls, the configured null value string is copied into the output.
+          int32_t next_column_offset =
+              static_cast<int32_t>(null_string_->size()) + /*end_char*/ 1;
+          memcpy((output + *offsets - next_column_offset), null_string_->data(),
+                 null_string_->size());
           *(output + *offsets - 1) = end_char_;
-          *offsets -= 1;
+          *offsets -= next_column_offset;
           offsets++;
         });
   }
@@ -175,8 +184,9 @@ class UnquotedColumnPopulator : public ColumnPopulator {
 // a quote character (") and escaping is done my adding another quote.
 class QuotedColumnPopulator : public ColumnPopulator {
  public:
-  QuotedColumnPopulator(MemoryPool* pool, char end_char)
-      : ColumnPopulator(pool, end_char) {}
+  QuotedColumnPopulator(MemoryPool* pool, char end_char,
+                        std::shared_ptr<Buffer> null_string)
+      : ColumnPopulator(pool, end_char, std::move(null_string)) {}
 
   Status UpdateRowLengths(int32_t* row_lengths) override {
     const StringArray& input = *casted_array_;
@@ -194,6 +204,7 @@ class QuotedColumnPopulator : public ColumnPopulator {
         },
         [&]() {
           row_needs_escaping_[row_number] = false;
+          row_lengths[row_number] += static_cast<int32_t>(null_string_->size());
           row_number++;
         });
     return Status::OK();
@@ -225,9 +236,13 @@ class QuotedColumnPopulator : public ColumnPopulator {
           needs_escaping++;
         },
         [&]() {
-          // Nulls are empty (unquoted) to distinguish with empty string.
+          // For nulls, the configured null value string is copied into the output.
+          int32_t next_column_offset =
+              static_cast<int32_t>(null_string_->size()) + /*end_char*/ 1;
+          memcpy((output + *offsets - next_column_offset), null_string_->data(),
+                 null_string_->size());
           *(output + *offsets - 1) = end_char_;
-          *offsets -= 1;
+          *offsets -= next_column_offset;
           offsets++;
           needs_escaping++;
         });
@@ -246,7 +261,7 @@ struct PopulatorFactory {
                   std::is_same<FixedSizeBinaryType, TypeClass>::value,
               Status>
   Visit(const TypeClass& type) {
-    populator = new QuotedColumnPopulator(pool, end_char);
+    populator = new QuotedColumnPopulator(pool, end_char, null_string);
     return Status::OK();
   }
 
@@ -267,18 +282,20 @@ struct PopulatorFactory {
                   is_null_type<TypeClass>::value || is_temporal_type<TypeClass>::value,
               Status>
   Visit(const TypeClass& type) {
-    populator = new UnquotedColumnPopulator(pool, end_char);
+    populator = new UnquotedColumnPopulator(pool, end_char, null_string);
     return Status::OK();
   }
 
   char end_char;
+  std::shared_ptr<Buffer> null_string;
   MemoryPool* pool;
   ColumnPopulator* populator;
 };
 
-Result<std::unique_ptr<ColumnPopulator>> MakePopulator(const Field& field, char end_char,
-                                                       MemoryPool* pool) {
-  PopulatorFactory factory{end_char, pool, nullptr};
+Result<std::unique_ptr<ColumnPopulator>> MakePopulator(
+    const Field& field, char end_char, std::shared_ptr<Buffer> null_string,
+    MemoryPool* pool) {
+  PopulatorFactory factory{end_char, std::move(null_string), pool, nullptr};
   RETURN_NOT_OK(VisitTypeInline(*field.type(), &factory));
   return std::unique_ptr<ColumnPopulator>(factory.populator);
 }
@@ -289,11 +306,22 @@ class CSVWriterImpl : public ipc::RecordBatchWriter {
       io::OutputStream* sink, std::shared_ptr<io::OutputStream> owned_sink,
       std::shared_ptr<Schema> schema, const WriteOptions& options) {
     RETURN_NOT_OK(options.Validate());
+    // Reject null string values that contain quotes.
+    if (CountEscapes(options.null_string) != 0) {
+      return Status::Invalid("Null string cannot contain quotes.");
+    }
+
+    ASSIGN_OR_RAISE(std::shared_ptr<Buffer> null_string,
+                    arrow::AllocateBuffer(options.null_string.length()));
+    memcpy(null_string->mutable_data(), options.null_string.data(),
+           options.null_string.length());
+
     std::vector<std::unique_ptr<ColumnPopulator>> populators(schema->num_fields());
     for (int col = 0; col < schema->num_fields(); col++) {
       char end_char = col < schema->num_fields() - 1 ? ',' : '\n';
-      ASSIGN_OR_RAISE(populators[col], MakePopulator(*schema->field(col), end_char,
-                                                     options.io_context.pool()));
+      ASSIGN_OR_RAISE(populators[col],
+                      MakePopulator(*schema->field(col), end_char, null_string,
+                                    options.io_context.pool()));
     }
     auto writer = std::make_shared<CSVWriterImpl>(
         sink, std::move(owned_sink), std::move(schema), std::move(populators), options);
diff --git a/cpp/src/arrow/csv/writer_test.cc b/cpp/src/arrow/csv/writer_test.cc
index 5d575887fdf..db93bfde68a 100644
--- a/cpp/src/arrow/csv/writer_test.cc
+++ b/cpp/src/arrow/csv/writer_test.cc
@@ -37,6 +37,7 @@ struct WriterTestParams {
   std::shared_ptr<Schema> schema;
   std::string batch_data;
   WriteOptions options;
+  bool options_invalid;
   std::string expected_output;
 };
 
@@ -45,21 +46,22 @@ void PrintTo(const WriterTestParams& p, std::ostream* os) {
   *os << "WriterTestParams(" << reinterpret_cast<const void*>(&p) << ")";
 }
 
-WriteOptions DefaultTestOptions(bool include_header) {
+WriteOptions DefaultTestOptions(bool include_header, const std::string& null_string) {
   WriteOptions options;
   options.batch_size = 5;
   options.include_header = include_header;
+  options.null_string = null_string;
   return options;
 }
 
 std::vector<WriterTestParams> GenerateTestCases() {
   auto abc_schema = schema({
-      {field("a", uint64())},
-      {field("b\"", utf8())},
-      {field("c ", int32())},
-      {field("d", date32())},
-      {field("e", date64())},
-      {field("f", timestamp(TimeUnit::SECOND))},
+      field("a", uint64()),
+      field("b\"", utf8()),
+      field("c ", int32()),
+      field("d", date32()),
+      field("e", date64()),
+      field("f", timestamp(TimeUnit::SECOND)),
   });
   auto populated_batch = R"([{"a": 1, "c ": -1},
                              { "a": 1, "b\"": "abc\"efg", "c ": 2324},
@@ -69,25 +71,54 @@ std::vector<WriterTestParams> GenerateTestCases() {
                              { "a": 124, "b\"": "a\"\"b\"" },
                              { "d": 0 },
                              { "e": 86400000 },
-                             { "f": 1078016523 }])";
-  std::string expected_without_header = std::string("1,,-1,,,") + "\n" +       // line 1
-                                        R"(1,"abc""efg",2324,,,)" + "\n" +     // line 2
-                                        R"(,"abcd",5467,,,)" + "\n" +          // line 3
-                                        R"(,,,,,)" + "\n" +                    // line 4
-                                        R"(546,"",517,,,)" + "\n" +            // line 5
-                                        R"(124,"a""""b""",,,,)" + "\n" +       // line 6
-                                        R"(,,,1970-01-01,,)" + "\n" +          // line 7
-                                        R"(,,,,1970-01-02,)" + "\n" +          // line 8
-                                        R"(,,,,,2004-02-29 01:02:03)" + "\n";  // line 9
+                             { "f": 1078016523 },
+                             { "b\"": "NA" }])";
+  std::string expected_without_header = std::string("1,,-1,,,") + "\n" +        // line 1
+                                        R"(1,"abc""efg",2324,,,)" + "\n" +      // line 2
+                                        R"(,"abcd",5467,,,)" + "\n" +           // line 3
+                                        R"(,,,,,)" + "\n" +                     // line 4
+                                        R"(546,"",517,,,)" + "\n" +             // line 5
+                                        R"(124,"a""""b""",,,,)" + "\n" +        // line 6
+                                        R"(,,,1970-01-01,,)" + "\n" +           // line 7
+                                        R"(,,,,1970-01-02,)" + "\n" +           // line 8
+                                        R"(,,,,,2004-02-29 01:02:03)" + "\n" +  // line 9
+                                        R"(,"NA",,,,)" + "\n";                  // line 10
+
   std::string expected_header = std::string(R"("a","b""","c ","d","e","f")") + "\n";
 
+  auto schema_custom_na = schema({field("g", uint64()), field("h", utf8())});
+
+  auto populated_batch_custom_na = R"([{"g": 42, "h": "NA"},
+                                                  { },
+                                                  {"g": 1337, "h": "\"NA\""}])";
+
+  std::string expected_custom_na = std::string(R"(42,"NA")") + "\n" +  // line 1
+                                   R"(NA,NA)" + "\n" +                 // line 2
+                                   R"(1337,"""NA""")" + "\n";          // line 3
+
+  std::string dummy_batch_data = R"([{"a": null}])";
+  auto dummy_schema = schema({field("a", uint8())});
+
   return std::vector<WriterTestParams>{
-      {abc_schema, "[]", DefaultTestOptions(/*header=*/false), ""},
-      {abc_schema, "[]", DefaultTestOptions(/*header=*/true), expected_header},
-      {abc_schema, populated_batch, DefaultTestOptions(/*header=*/false),
-       expected_without_header},
-      {abc_schema, populated_batch, DefaultTestOptions(/*header=*/true),
-       expected_header + expected_without_header}};
+      {abc_schema, "[]", DefaultTestOptions(/*include_header=*/false, /*null_string=*/""),
+       /*null_string_invalid*/ false, ""},
+      {abc_schema, "[]", DefaultTestOptions(/*include_header=*/true, /*null_string=*/""),
+       /*null_string_invalid*/ false, expected_header},
+      {abc_schema, populated_batch,
+       DefaultTestOptions(/*include_header=*/false, /*null_string=*/""),
+       /*null_string_invalid*/ false, expected_without_header},
+      {abc_schema, populated_batch,
+       DefaultTestOptions(/*include_header=*/true, /*null_string=*/""),
+       /*null_string_invalid*/ false, expected_header + expected_without_header},
+      {schema_custom_na, populated_batch_custom_na,
+       DefaultTestOptions(/*include_header=*/false, /*null_string=*/"NA"),
+       /*null_string_invalid*/ false, expected_custom_na},
+      {dummy_schema, dummy_batch_data,
+       DefaultTestOptions(/*include_header=*/false, /*null_string=*/R"("NA")"),
+       /*null_string_invalid*/ true, ""},
+      {dummy_schema, dummy_batch_data,
+       DefaultTestOptions(/*include_header=*/false, /*null_string=*/R"(")"),
+       /*null_string_invalid*/ true, ""}};
 }
 
 class TestWriteCSV : public ::testing::TestWithParam<WriterTestParams> {
@@ -129,23 +160,28 @@ TEST_P(TestWriteCSV, TestWrite) {
   WriteOptions options = GetParam().options;
   std::string csv;
   auto record_batch = RecordBatchFromJSON(GetParam().schema, GetParam().batch_data);
-  ASSERT_OK_AND_ASSIGN(csv, ToCsvString(*record_batch, options));
-  EXPECT_EQ(csv, GetParam().expected_output);
-
-  // Batch size shouldn't matter.
-  options.batch_size /= 2;
-  ASSERT_OK_AND_ASSIGN(csv, ToCsvString(*record_batch, options));
-  EXPECT_EQ(csv, GetParam().expected_output);
-
-  // Table and Record batch should work identically.
-  ASSERT_OK_AND_ASSIGN(std::shared_ptr<Table> table,
-                       Table::FromRecordBatches({record_batch}));
-  ASSERT_OK_AND_ASSIGN(csv, ToCsvString(*table, options));
-  EXPECT_EQ(csv, GetParam().expected_output);
-
-  // The writer should work identically.
-  ASSERT_OK_AND_ASSIGN(csv, ToCsvStringUsingWriter(*table, options));
-  EXPECT_EQ(csv, GetParam().expected_output);
+  // Invalid options should be rejected.
+  if (GetParam().options_invalid) {
+    ASSERT_RAISES(Invalid, ToCsvString(*record_batch, options));
+  } else {
+    ASSERT_OK_AND_ASSIGN(csv, ToCsvString(*record_batch, options));
+    EXPECT_EQ(csv, GetParam().expected_output);
+
+    // Batch size shouldn't matter.
+    options.batch_size /= 2;
+    ASSERT_OK_AND_ASSIGN(csv, ToCsvString(*record_batch, options));
+    EXPECT_EQ(csv, GetParam().expected_output);
+
+    // Table and Record batch should work identically.
+    ASSERT_OK_AND_ASSIGN(std::shared_ptr<Table> table,
+                         Table::FromRecordBatches({record_batch}));
+    ASSERT_OK_AND_ASSIGN(csv, ToCsvString(*table, options));
+    EXPECT_EQ(csv, GetParam().expected_output);
+
+    // The writer should work identically.
+    ASSERT_OK_AND_ASSIGN(csv, ToCsvStringUsingWriter(*table, options));
+    EXPECT_EQ(csv, GetParam().expected_output);
+  }
 }
 
 INSTANTIATE_TEST_SUITE_P(MultiColumnWriteCSVTest, TestWriteCSV,
@@ -155,6 +191,7 @@ INSTANTIATE_TEST_SUITE_P(SingleColumnWriteCSVTest, TestWriteCSV,
                          ::testing::Values(WriterTestParams{
                              schema({field("int64", int64())}),
                              R"([{ "int64": 9999}, {}, { "int64": -15}])", WriteOptions(),
+                             false,
                              R"("int64")"
                              "\n9999\n\n-15\n"}));
 
@@ -167,7 +204,7 @@ INSTANTIATE_TEST_SUITE_P(
             field("tz", timestamp(TimeUnit::SECOND, "America/Phoenix")),
             field("utc", timestamp(TimeUnit::SECOND, "UTC")),
         }),
-        R"([{ "tz": 1456767743, "utc": 1456767743 }])", WriteOptions(),
+        R"([{ "tz": 1456767743, "utc": 1456767743 }])", WriteOptions(), false,
         R"("tz","utc")"
         "\n2016-02-29 10:42:23-0700,2016-02-29 17:42:23Z\n"}));
 #endif
diff --git a/cpp/src/arrow/dataset/dataset.cc b/cpp/src/arrow/dataset/dataset.cc
index 680713a7ba5..5c714a5d5b7 100644
--- a/cpp/src/arrow/dataset/dataset.cc
+++ b/cpp/src/arrow/dataset/dataset.cc
@@ -91,7 +91,7 @@ Result<ScanTaskIterator> InMemoryFragment::Scan(std::shared_ptr<ScanOptions> opt
   auto fn = [=](std::shared_ptr<RecordBatch> batch) -> std::shared_ptr<ScanTask> {
     RecordBatchVector batches;
 
-    auto n_batches = BitUtil::CeilDiv(batch->num_rows(), batch_size);
+    auto n_batches = bit_util::CeilDiv(batch->num_rows(), batch_size);
     for (int i = 0; i < n_batches; i++) {
       batches.push_back(batch->Slice(batch_size * i, batch_size));
     }
diff --git a/cpp/src/arrow/filesystem/gcsfs.cc b/cpp/src/arrow/filesystem/gcsfs.cc
index aa69890d336..6b71a2c5cb1 100644
--- a/cpp/src/arrow/filesystem/gcsfs.cc
+++ b/cpp/src/arrow/filesystem/gcsfs.cc
@@ -73,10 +73,20 @@ struct GcsPath {
 
 class GcsInputStream : public arrow::io::InputStream {
  public:
-  explicit GcsInputStream(gcs::ObjectReadStream stream) : stream_(std::move(stream)) {}
+  explicit GcsInputStream(gcs::ObjectReadStream stream, std::string bucket_name,
+                          std::string object_name, gcs::Generation generation,
+                          gcs::ReadFromOffset offset, gcs::Client client)
+      : stream_(std::move(stream)),
+        bucket_name_(std::move(bucket_name)),
+        object_name_(std::move(object_name)),
+        generation_(generation),
+        offset_(offset.value_or(0)),
+        client_(std::move(client)) {}
 
   ~GcsInputStream() override = default;
 
+  //@{
+  // @name FileInterface
   Status Close() override {
     stream_.Close();
     return Status::OK();
@@ -86,11 +96,14 @@ class GcsInputStream : public arrow::io::InputStream {
     if (!stream_) {
       return Status::IOError("invalid stream");
     }
-    return stream_.tellg();
+    return stream_.tellg() + offset_;
   }
 
   bool closed() const override { return !stream_.IsOpen(); }
+  //@}
 
+  //@{
+  // @name Readable
   Result<int64_t> Read(int64_t nbytes, void* out) override {
     stream_.read(static_cast<char*>(out), nbytes);
     ARROW_GCS_RETURN_NOT_OK(stream_.status());
@@ -104,9 +117,24 @@ class GcsInputStream : public arrow::io::InputStream {
     RETURN_NOT_OK(buffer->Resize(stream_.gcount(), true));
     return buffer;
   }
+  //@}
+
+  //@{
+  // @name InputStream
+  Result<std::shared_ptr<const KeyValueMetadata>> ReadMetadata() override {
+    auto metadata = client_.GetObjectMetadata(bucket_name_, object_name_, generation_);
+    ARROW_GCS_RETURN_NOT_OK(metadata.status());
+    return internal::FromObjectMetadata(*metadata);
+  }
+  //@}
 
  private:
   mutable gcs::ObjectReadStream stream_;
+  std::string bucket_name_;
+  std::string object_name_;
+  gcs::Generation generation_;
+  std::int64_t offset_;
+  gcs::Client client_;
 };
 
 class GcsOutputStream : public arrow::io::OutputStream {
@@ -146,6 +174,79 @@ class GcsOutputStream : public arrow::io::OutputStream {
   int64_t tell_ = 0;
 };
 
+using InputStreamFactory = std::function<Result<std::shared_ptr<io::InputStream>>(
+    const std::string&, const std::string&, gcs::Generation, gcs::ReadFromOffset)>;
+
+class GcsRandomAccessFile : public arrow::io::RandomAccessFile {
+ public:
+  GcsRandomAccessFile(InputStreamFactory factory, gcs::ObjectMetadata metadata,
+                      std::shared_ptr<io::InputStream> stream)
+      : factory_(std::move(factory)),
+        metadata_(std::move(metadata)),
+        stream_(std::move(stream)) {}
+  ~GcsRandomAccessFile() override = default;
+
+  //@{
+  // @name FileInterface
+  Status Close() override { return stream_->Close(); }
+  Status Abort() override { return stream_->Abort(); }
+  Result<int64_t> Tell() const override { return stream_->Tell(); }
+  bool closed() const override { return stream_->closed(); }
+  //@}
+
+  //@{
+  // @name Readable
+  Result<int64_t> Read(int64_t nbytes, void* out) override {
+    return stream_->Read(nbytes, out);
+  }
+  Result<std::shared_ptr<Buffer>> Read(int64_t nbytes) override {
+    return stream_->Read(nbytes);
+  }
+  const arrow::io::IOContext& io_context() const override {
+    return stream_->io_context();
+  }
+  //@}
+
+  //@{
+  // @name InputStream
+  Result<std::shared_ptr<const KeyValueMetadata>> ReadMetadata() override {
+    return internal::FromObjectMetadata(metadata_);
+  }
+  //@}
+
+  //@{
+  // @name RandomAccessFile
+  Result<int64_t> GetSize() override { return metadata_.size(); }
+  Result<int64_t> ReadAt(int64_t position, int64_t nbytes, void* out) override {
+    std::shared_ptr<io::InputStream> stream;
+    ARROW_ASSIGN_OR_RAISE(stream, factory_(metadata_.bucket(), metadata_.name(),
+                                           gcs::Generation(metadata_.generation()),
+                                           gcs::ReadFromOffset(position)));
+    return stream->Read(nbytes, out);
+  }
+  Result<std::shared_ptr<Buffer>> ReadAt(int64_t position, int64_t nbytes) override {
+    std::shared_ptr<io::InputStream> stream;
+    ARROW_ASSIGN_OR_RAISE(stream, factory_(metadata_.bucket(), metadata_.name(),
+                                           gcs::Generation(metadata_.generation()),
+                                           gcs::ReadFromOffset(position)));
+    return stream->Read(nbytes);
+  }
+  //@}
+
+  // from Seekable
+  Status Seek(int64_t position) override {
+    ARROW_ASSIGN_OR_RAISE(stream_, factory_(metadata_.bucket(), metadata_.name(),
+                                            gcs::Generation(metadata_.generation()),
+                                            gcs::ReadFromOffset(position)));
+    return Status::OK();
+  }
+
+ private:
+  InputStreamFactory factory_;
+  gcs::ObjectMetadata metadata_;
+  std::shared_ptr<io::InputStream> stream_;
+};
+
 }  // namespace
 
 google::cloud::Options AsGoogleCloudOptions(const GcsOptions& o) {
@@ -182,10 +283,28 @@ class GcsFileSystem::Impl {
     return GetFileInfoImpl(path, std::move(meta).status(), FileType::Directory);
   }
 
-  Result<std::shared_ptr<io::InputStream>> OpenInputStream(const GcsPath& path) {
-    auto stream = client_.ReadObject(path.bucket, path.object);
+  Status DeleteFile(const GcsPath& p) {
+    if (!p.object.empty() && p.object.back() == '/') {
+      return Status::IOError("The given path (" + p.full_path +
+                             ") is a directory, use DeleteDir");
+    }
+    return internal::ToArrowStatus(client_.DeleteObject(p.bucket, p.object));
+  }
+
+  Status CopyFile(const GcsPath& src, const GcsPath& dest) {
+    auto metadata =
+        client_.RewriteObjectBlocking(src.bucket, src.object, dest.bucket, dest.object);
+    return internal::ToArrowStatus(metadata.status());
+  }
+
+  Result<std::shared_ptr<io::InputStream>> OpenInputStream(const std::string& bucket_name,
+                                                           const std::string& object_name,
+                                                           gcs::Generation generation,
+                                                           gcs::ReadFromOffset offset) {
+    auto stream = client_.ReadObject(bucket_name, object_name, generation, offset);
     ARROW_GCS_RETURN_NOT_OK(stream.status());
-    return std::make_shared<GcsInputStream>(std::move(stream));
+    return std::make_shared<GcsInputStream>(std::move(stream), bucket_name, object_name,
+                                            gcs::Generation(), offset, client_);
   }
 
   Result<std::shared_ptr<io::OutputStream>> OpenOutputStream(
@@ -205,6 +324,10 @@ class GcsFileSystem::Impl {
     return std::make_shared<GcsOutputStream>(std::move(stream));
   }
 
+  google::cloud::StatusOr<gcs::ObjectMetadata> GetObjectMetadata(const GcsPath& path) {
+    return client_.GetObjectMetadata(path.bucket, path.object);
+  }
+
  private:
   static Result<FileInfo> GetFileInfoImpl(const GcsPath& path,
                                           const google::cloud::Status& status,
@@ -262,11 +385,14 @@ Status GcsFileSystem::DeleteDirContents(const std::string& path) {
 }
 
 Status GcsFileSystem::DeleteRootDirContents() {
-  return Status::NotImplemented("The GCS FileSystem is not fully implemented");
+  return Status::NotImplemented(
+      std::string(__func__) +
+      " is not implemented as it is too dangerous to delete all the buckets");
 }
 
 Status GcsFileSystem::DeleteFile(const std::string& path) {
-  return Status::NotImplemented("The GCS FileSystem is not fully implemented");
+  ARROW_ASSIGN_OR_RAISE(auto p, GcsPath::FromString(path));
+  return impl_->DeleteFile(p);
 }
 
 Status GcsFileSystem::Move(const std::string& src, const std::string& dest) {
@@ -274,13 +400,16 @@ Status GcsFileSystem::Move(const std::string& src, const std::string& dest) {
 }
 
 Status GcsFileSystem::CopyFile(const std::string& src, const std::string& dest) {
-  return Status::NotImplemented("The GCS FileSystem is not fully implemented");
+  ARROW_ASSIGN_OR_RAISE(auto s, GcsPath::FromString(src));
+  ARROW_ASSIGN_OR_RAISE(auto d, GcsPath::FromString(dest));
+  return impl_->CopyFile(s, d);
 }
 
 Result<std::shared_ptr<io::InputStream>> GcsFileSystem::OpenInputStream(
     const std::string& path) {
   ARROW_ASSIGN_OR_RAISE(auto p, GcsPath::FromString(path));
-  return impl_->OpenInputStream(p);
+  return impl_->OpenInputStream(p.bucket, p.object, gcs::Generation(),
+                                gcs::ReadFromOffset());
 }
 
 Result<std::shared_ptr<io::InputStream>> GcsFileSystem::OpenInputStream(
@@ -289,17 +418,46 @@ Result<std::shared_ptr<io::InputStream>> GcsFileSystem::OpenInputStream(
     return Status::IOError("Only files can be opened as input streams");
   }
   ARROW_ASSIGN_OR_RAISE(auto p, GcsPath::FromString(info.path()));
-  return impl_->OpenInputStream(p);
+  return impl_->OpenInputStream(p.bucket, p.object, gcs::Generation(),
+                                gcs::ReadFromOffset());
 }
 
 Result<std::shared_ptr<io::RandomAccessFile>> GcsFileSystem::OpenInputFile(
     const std::string& path) {
-  return Status::NotImplemented("The GCS FileSystem is not fully implemented");
+  ARROW_ASSIGN_OR_RAISE(auto p, GcsPath::FromString(path));
+  auto metadata = impl_->GetObjectMetadata(p);
+  ARROW_GCS_RETURN_NOT_OK(metadata.status());
+  auto impl = impl_;
+  auto open_stream = [impl](const std::string& b, const std::string& o, gcs::Generation g,
+                            gcs::ReadFromOffset offset) {
+    return impl->OpenInputStream(b, o, g, offset);
+  };
+  ARROW_ASSIGN_OR_RAISE(
+      auto stream,
+      impl_->OpenInputStream(p.bucket, p.object, gcs::Generation(metadata->generation()),
+                             gcs::ReadFromOffset()));
+
+  return std::make_shared<GcsRandomAccessFile>(std::move(open_stream),
+                                               *std::move(metadata), std::move(stream));
 }
 
 Result<std::shared_ptr<io::RandomAccessFile>> GcsFileSystem::OpenInputFile(
     const FileInfo& info) {
-  return Status::NotImplemented("The GCS FileSystem is not fully implemented");
+  ARROW_ASSIGN_OR_RAISE(auto p, GcsPath::FromString(info.path()));
+  auto metadata = impl_->GetObjectMetadata(p);
+  ARROW_GCS_RETURN_NOT_OK(metadata.status());
+  auto impl = impl_;
+  auto open_stream = [impl](const std::string& b, const std::string& o, gcs::Generation g,
+                            gcs::ReadFromOffset offset) {
+    return impl->OpenInputStream(b, o, g, offset);
+  };
+  ARROW_ASSIGN_OR_RAISE(
+      auto stream,
+      impl_->OpenInputStream(p.bucket, p.object, gcs::Generation(metadata->generation()),
+                             gcs::ReadFromOffset()));
+
+  return std::make_shared<GcsRandomAccessFile>(std::move(open_stream),
+                                               *std::move(metadata), std::move(stream));
 }
 
 Result<std::shared_ptr<io::OutputStream>> GcsFileSystem::OpenOutputStream(
diff --git a/cpp/src/arrow/filesystem/gcsfs_internal.cc b/cpp/src/arrow/filesystem/gcsfs_internal.cc
index 759e95feb73..e4cb38ade92 100644
--- a/cpp/src/arrow/filesystem/gcsfs_internal.cc
+++ b/cpp/src/arrow/filesystem/gcsfs_internal.cc
@@ -22,6 +22,7 @@
 
 #include <sstream>
 #include <unordered_map>
+#include <vector>
 
 #include "arrow/util/key_value_metadata.h"
 
@@ -193,6 +194,70 @@ Result<gcs::WithObjectMetadata> ToObjectMetadata(
   return gcs::WithObjectMetadata(std::move(object_metadata));
 }
 
+Result<std::shared_ptr<const KeyValueMetadata>> FromObjectMetadata(
+    gcs::ObjectMetadata const& m) {
+  auto format_time = [](std::chrono::system_clock::time_point tp) {
+    return absl::FormatTime(absl::RFC3339_full, absl::FromChrono(tp),
+                            absl::UTCTimeZone());
+  };
+  auto result = std::make_shared<KeyValueMetadata>();
+  // The fields are in the same order as defined in:
+  //  https://cloud.google.com/storage/docs/json_api/v1/objects
+  // Where previous practice in Arrow suggested using a different field name (Content-Type
+  // vs. contentType) we prefer the existing practice in Arrow.
+  result->Append("id", m.id());
+  result->Append("selfLink", m.self_link());
+  result->Append("name", m.name());
+  result->Append("bucket", m.bucket());
+  result->Append("generation", std::to_string(m.generation()));
+  result->Append("Content-Type", m.content_type());
+  result->Append("timeCreated", format_time(m.time_created()));
+  result->Append("updated", format_time(m.updated()));
+  if (m.has_custom_time()) {
+    result->Append("customTime", format_time(m.custom_time()));
+  }
+  if (m.time_deleted() != std::chrono::system_clock::time_point()) {
+    result->Append("timeDeleted", format_time(m.time_deleted()));
+  }
+  result->Append("temporaryHold", m.temporary_hold() ? "true" : "false");
+  result->Append("eventBasedHold", m.event_based_hold() ? "true" : "false");
+  if (m.retention_expiration_time() != std::chrono::system_clock::time_point()) {
+    result->Append("retentionExpirationTime", format_time(m.retention_expiration_time()));
+  }
+  result->Append("storageClass", m.storage_class());
+  if (m.time_storage_class_updated() != std::chrono::system_clock::time_point()) {
+    result->Append("timeStorageClassUpdated",
+                   format_time(m.time_storage_class_updated()));
+  }
+  result->Append("size", std::to_string(m.size()));
+  result->Append("md5Hash", m.md5_hash());
+  result->Append("mediaLink", m.media_link());
+  result->Append("Content-Encoding", m.content_encoding());
+  result->Append("Content-Disposition", m.content_disposition());
+  result->Append("Content-Language", m.content_language());
+  result->Append("Cache-Control", m.cache_control());
+  for (auto const& kv : m.metadata()) {
+    result->Append("metadata." + kv.first, kv.second);
+  }
+  // Skip "acl" because it is overly complex
+  if (m.has_owner()) {
+    result->Append("owner.entity", m.owner().entity);
+    result->Append("owner.entityId", m.owner().entity_id);
+  }
+  result->Append("crc32c", m.crc32c());
+  result->Append("componentCount", std::to_string(m.component_count()));
+  result->Append("etag", m.etag());
+  if (m.has_customer_encryption()) {
+    result->Append("customerEncryption.encryptionAlgorithm",
+                   m.customer_encryption().encryption_algorithm);
+    result->Append("customerEncryption.keySha256", m.customer_encryption().key_sha256);
+  }
+  if (!m.kms_key_name().empty()) {
+    result->Append("kmsKeyName", m.kms_key_name());
+  }
+  return result;
+}
+
 }  // namespace internal
 }  // namespace fs
 }  // namespace arrow
diff --git a/cpp/src/arrow/filesystem/gcsfs_internal.h b/cpp/src/arrow/filesystem/gcsfs_internal.h
index 938d08d6323..fc7789ff0f5 100644
--- a/cpp/src/arrow/filesystem/gcsfs_internal.h
+++ b/cpp/src/arrow/filesystem/gcsfs_internal.h
@@ -46,6 +46,9 @@ Result<google::cloud::storage::KmsKeyName> ToKmsKeyName(
 Result<google::cloud::storage::WithObjectMetadata> ToObjectMetadata(
     const std::shared_ptr<const KeyValueMetadata>& metadata);
 
+Result<std::shared_ptr<const KeyValueMetadata>> FromObjectMetadata(
+    google::cloud::storage::ObjectMetadata const& m);
+
 }  // namespace internal
 }  // namespace fs
 }  // namespace arrow
diff --git a/cpp/src/arrow/filesystem/gcsfs_test.cc b/cpp/src/arrow/filesystem/gcsfs_test.cc
index 3304d4bcc73..30d37c18bf1 100644
--- a/cpp/src/arrow/filesystem/gcsfs_test.cc
+++ b/cpp/src/arrow/filesystem/gcsfs_test.cc
@@ -17,6 +17,7 @@
 
 #include "arrow/filesystem/gcsfs.h"
 
+#include <absl/time/time.h>
 #include <gmock/gmock-matchers.h>
 #include <gmock/gmock-more-matchers.h>
 #include <google/cloud/credentials.h>
@@ -26,6 +27,7 @@
 
 #include <array>
 #include <boost/process.hpp>
+#include <random>
 #include <string>
 
 #include "arrow/filesystem/gcsfs_internal.h"
@@ -72,6 +74,8 @@ class GcsIntegrationTest : public ::testing::Test {
 
  protected:
   void SetUp() override {
+    // Initialize a PRNG with a small amount of entropy.
+    generator_ = std::mt19937_64(std::random_device()());
     port_ = std::to_string(GetListenPort());
     auto exe_path = bp::search_path("python3");
     ASSERT_THAT(exe_path, Not(IsEmpty()));
@@ -111,7 +115,30 @@ class GcsIntegrationTest : public ::testing::Test {
     return options;
   }
 
+  gcs::Client GcsClient() {
+    return gcs::Client(
+        google::cloud::Options{}
+            .set<gcs::RestEndpointOption>("http://127.0.0.1:" + port_)
+            .set<gc::UnifiedCredentialsOption>(gc::MakeInsecureCredentials()));
+  }
+
+  std::string RandomLine(int lineno, std::size_t width) {
+    auto const fillers = std::string("abcdefghijlkmnopqrstuvwxyz0123456789");
+    std::uniform_int_distribution<std::size_t> d(0, fillers.size() - 1);
+
+    auto line = std::to_string(lineno) + ":    ";
+    std::generate_n(std::back_inserter(line), width - line.size() - 1,
+                    [&] { return fillers[d(generator_)]; });
+    line += '\n';
+    return line;
+  }
+
+  int RandomIndex(std::size_t end) {
+    return std::uniform_int_distribution<std::size_t>(0, end - 1)(generator_);
+  }
+
  private:
+  std::mt19937_64 generator_;
   std::string port_;
   bp::child server_process_;
 };
@@ -276,6 +303,35 @@ TEST(GcsFileSystem, ToObjectMetadataInvalidCustomTime) {
   EXPECT_THAT(metadata.status().message(), HasSubstr("Error parsing RFC-3339"));
 }
 
+TEST(GcsFileSystem, ObjectMetadataRoundtrip) {
+  const auto source = KeyValueMetadataForTest();
+  gcs::WithObjectMetadata tmp;
+  ASSERT_OK_AND_ASSIGN(tmp, arrow::fs::internal::ToObjectMetadata(source));
+  std::shared_ptr<const KeyValueMetadata> destination;
+  ASSERT_OK_AND_ASSIGN(destination, arrow::fs::internal::FromObjectMetadata(tmp.value()));
+  // Only a subset of the keys are configurable in gcs::ObjectMetadata, for example, the
+  // size and CRC32C values of an object are only settable when the metadata is received
+  // from the services. For those keys that should be preserved, verify they are preserved
+  // in the round trip.
+  for (auto key : {"Cache-Control", "Content-Disposition", "Content-Encoding",
+                   "Content-Language", "Content-Type", "storageClass"}) {
+    SCOPED_TRACE("Testing key " + std::string(key));
+    ASSERT_OK_AND_ASSIGN(auto s, source->Get(key));
+    ASSERT_OK_AND_ASSIGN(auto d, destination->Get(key));
+    EXPECT_EQ(s, d);
+  }
+  // RFC-3339 formatted timestamps may differ in trivial things, e.g., the UTC timezone
+  // can be represented as 'Z' or '+00:00'.
+  ASSERT_OK_AND_ASSIGN(auto s, source->Get("customTime"));
+  ASSERT_OK_AND_ASSIGN(auto d, destination->Get("customTime"));
+  std::string err;
+  absl::Time ts;
+  absl::Time td;
+  ASSERT_TRUE(absl::ParseTime(absl::RFC3339_full, s, &ts, &err)) << "error=" << err;
+  ASSERT_TRUE(absl::ParseTime(absl::RFC3339_full, d, &td, &err)) << "error=" << err;
+  EXPECT_NEAR(absl::ToDoubleSeconds(ts - td), 0, 0.5);
+}
+
 TEST_F(GcsIntegrationTest, GetFileInfoBucket) {
   auto fs = internal::MakeGcsFileSystemForTest(TestGcsOptions());
   arrow::fs::AssertFileInfo(fs.get(), kPreexistingBucket, FileType::Directory);
@@ -286,6 +342,42 @@ TEST_F(GcsIntegrationTest, GetFileInfoObject) {
   arrow::fs::AssertFileInfo(fs.get(), PreexistingObjectPath(), FileType::File);
 }
 
+TEST_F(GcsIntegrationTest, DeleteRootDirContents) {
+  auto fs = internal::MakeGcsFileSystemForTest(TestGcsOptions());
+  EXPECT_RAISES_WITH_MESSAGE_THAT(NotImplemented, HasSubstr("too dangerous"),
+                                  fs->DeleteRootDirContents());
+}
+
+TEST_F(GcsIntegrationTest, DeleteFileSuccess) {
+  auto fs = internal::MakeGcsFileSystemForTest(TestGcsOptions());
+  ASSERT_OK(fs->DeleteFile(PreexistingObjectPath()));
+  arrow::fs::AssertFileInfo(fs.get(), PreexistingObjectPath(), FileType::NotFound);
+}
+
+TEST_F(GcsIntegrationTest, DeleteFileFailure) {
+  auto fs = internal::MakeGcsFileSystemForTest(TestGcsOptions());
+  ASSERT_RAISES(IOError, fs->DeleteFile(NotFoundObjectPath()));
+}
+
+TEST_F(GcsIntegrationTest, DeleteFileDirectoryFails) {
+  auto fs = internal::MakeGcsFileSystemForTest(TestGcsOptions());
+  const auto path = std::string(kPreexistingBucket) + "/DeleteFileDirectoryFails/";
+  ASSERT_RAISES(IOError, fs->DeleteFile(path));
+}
+
+TEST_F(GcsIntegrationTest, CopyFileSuccess) {
+  auto fs = internal::MakeGcsFileSystemForTest(TestGcsOptions());
+  const auto destination_path = kPreexistingBucket + std::string("/copy-destination");
+  ASSERT_OK(fs->CopyFile(PreexistingObjectPath(), destination_path));
+  arrow::fs::AssertFileInfo(fs.get(), destination_path, FileType::File);
+}
+
+TEST_F(GcsIntegrationTest, CopyFileNotFound) {
+  auto fs = internal::MakeGcsFileSystemForTest(TestGcsOptions());
+  const auto destination_path = kPreexistingBucket + std::string("/copy-destination");
+  ASSERT_RAISES(IOError, fs->CopyFile(NotFoundObjectPath(), destination_path));
+}
+
 TEST_F(GcsIntegrationTest, ReadObjectString) {
   auto fs = internal::MakeGcsFileSystemForTest(TestGcsOptions());
 
@@ -334,8 +426,7 @@ TEST_F(GcsIntegrationTest, ReadObjectInfo) {
 TEST_F(GcsIntegrationTest, ReadObjectNotFound) {
   auto fs = internal::MakeGcsFileSystemForTest(TestGcsOptions());
 
-  auto result = fs->OpenInputStream(NotFoundObjectPath());
-  EXPECT_EQ(result.status().code(), StatusCode::IOError);
+  ASSERT_RAISES(IOError, fs->OpenInputStream(NotFoundObjectPath()));
 }
 
 TEST_F(GcsIntegrationTest, ReadObjectInfoInvalid) {
@@ -343,13 +434,72 @@ TEST_F(GcsIntegrationTest, ReadObjectInfoInvalid) {
 
   arrow::fs::FileInfo info;
   ASSERT_OK_AND_ASSIGN(info, fs->GetFileInfo(kPreexistingBucket));
-
-  auto result = fs->OpenInputStream(NotFoundObjectPath());
-  EXPECT_EQ(result.status().code(), StatusCode::IOError);
+  ASSERT_RAISES(IOError, fs->OpenInputStream(info));
 
   ASSERT_OK_AND_ASSIGN(info, fs->GetFileInfo(NotFoundObjectPath()));
-  result = fs->OpenInputStream(NotFoundObjectPath());
-  EXPECT_EQ(result.status().code(), StatusCode::IOError);
+  ASSERT_RAISES(IOError, fs->OpenInputStream(info));
+}
+
+TEST_F(GcsIntegrationTest, ReadObjectReadMetadata) {
+  auto client = GcsClient();
+  const auto custom_time = std::chrono::system_clock::now() + std::chrono::hours(1);
+  const std::string object_name = "ReadObjectMetadataTest/simple.txt";
+  const gcs::ObjectMetadata expected =
+      client
+          .InsertObject(kPreexistingBucket, object_name,
+                        "The quick brown fox jumps over the lazy dog",
+                        gcs::WithObjectMetadata(gcs::ObjectMetadata()
+                                                    .set_content_type("text/plain")
+                                                    .set_custom_time(custom_time)
+                                                    .set_cache_control("no-cache")
+                                                    .upsert_metadata("key0", "value0")))
+          .value();
+
+  auto fs = internal::MakeGcsFileSystemForTest(TestGcsOptions());
+  std::shared_ptr<io::InputStream> stream;
+  ASSERT_OK_AND_ASSIGN(
+      stream, fs->OpenInputStream(std::string(kPreexistingBucket) + "/" + object_name));
+
+  auto format_time = [](std::chrono::system_clock::time_point tp) {
+    return absl::FormatTime(absl::RFC3339_full, absl::FromChrono(tp),
+                            absl::UTCTimeZone());
+  };
+
+  std::shared_ptr<const KeyValueMetadata> actual;
+  ASSERT_OK_AND_ASSIGN(actual, stream->ReadMetadata());
+  ASSERT_OK_AND_EQ(expected.self_link(), actual->Get("selfLink"));
+  ASSERT_OK_AND_EQ(expected.name(), actual->Get("name"));
+  ASSERT_OK_AND_EQ(expected.bucket(), actual->Get("bucket"));
+  ASSERT_OK_AND_EQ(std::to_string(expected.generation()), actual->Get("generation"));
+  ASSERT_OK_AND_EQ(expected.content_type(), actual->Get("Content-Type"));
+  ASSERT_OK_AND_EQ(format_time(expected.time_created()), actual->Get("timeCreated"));
+  ASSERT_OK_AND_EQ(format_time(expected.updated()), actual->Get("updated"));
+  ASSERT_FALSE(actual->Contains("timeDeleted"));
+  ASSERT_OK_AND_EQ(format_time(custom_time), actual->Get("customTime"));
+  ASSERT_OK_AND_EQ("false", actual->Get("temporaryHold"));
+  ASSERT_OK_AND_EQ("false", actual->Get("eventBasedHold"));
+  ASSERT_FALSE(actual->Contains("retentionExpirationTime"));
+  ASSERT_OK_AND_EQ(expected.storage_class(), actual->Get("storageClass"));
+  ASSERT_FALSE(actual->Contains("storageClassUpdated"));
+  ASSERT_OK_AND_EQ(std::to_string(expected.size()), actual->Get("size"));
+  ASSERT_OK_AND_EQ(expected.md5_hash(), actual->Get("md5Hash"));
+  ASSERT_OK_AND_EQ(expected.media_link(), actual->Get("mediaLink"));
+  ASSERT_OK_AND_EQ(expected.content_encoding(), actual->Get("Content-Encoding"));
+  ASSERT_OK_AND_EQ(expected.content_disposition(), actual->Get("Content-Disposition"));
+  ASSERT_OK_AND_EQ(expected.content_language(), actual->Get("Content-Language"));
+  ASSERT_OK_AND_EQ(expected.cache_control(), actual->Get("Cache-Control"));
+  auto p = expected.metadata().find("key0");
+  ASSERT_TRUE(p != expected.metadata().end());
+  ASSERT_OK_AND_EQ(p->second, actual->Get("metadata.key0"));
+  ASSERT_EQ(expected.has_owner(), actual->Contains("owner.entity"));
+  ASSERT_EQ(expected.has_owner(), actual->Contains("owner.entityId"));
+  ASSERT_OK_AND_EQ(expected.crc32c(), actual->Get("crc32c"));
+  ASSERT_OK_AND_EQ(std::to_string(expected.component_count()),
+                   actual->Get("componentCount"));
+  ASSERT_OK_AND_EQ(expected.etag(), actual->Get("etag"));
+  ASSERT_FALSE(actual->Contains("customerEncryption.encryptionAlgorithm"));
+  ASSERT_FALSE(actual->Contains("customerEncryption.keySha256"));
+  ASSERT_FALSE(actual->Contains("kmsKeyName"));
 }
 
 TEST_F(GcsIntegrationTest, WriteObjectSmall) {
@@ -409,6 +559,126 @@ TEST_F(GcsIntegrationTest, WriteObjectLarge) {
   EXPECT_EQ(contents, buffers[0] + buffers[1] + buffers[2]);
 }
 
+TEST_F(GcsIntegrationTest, OpenInputFileMixedReadVsReadAt) {
+  auto fs = internal::MakeGcsFileSystemForTest(TestGcsOptions());
+
+  // Create a file large enough to make the random access tests non-trivial.
+  auto constexpr kLineWidth = 100;
+  auto constexpr kLineCount = 4096;
+  std::vector<std::string> lines(kLineCount);
+  int lineno = 0;
+  std::generate_n(lines.begin(), lines.size(),
+                  [&] { return RandomLine(++lineno, kLineWidth); });
+
+  const auto path =
+      kPreexistingBucket + std::string("/OpenInputFileMixedReadVsReadAt/object-name");
+  std::shared_ptr<io::OutputStream> output;
+  ASSERT_OK_AND_ASSIGN(output, fs->OpenOutputStream(path, {}));
+  for (auto const& line : lines) {
+    ASSERT_OK(output->Write(line.data(), line.size()));
+  }
+  ASSERT_OK(output->Close());
+
+  std::shared_ptr<io::RandomAccessFile> file;
+  ASSERT_OK_AND_ASSIGN(file, fs->OpenInputFile(path));
+  for (int i = 0; i != 32; ++i) {
+    SCOPED_TRACE("Iteration " + std::to_string(i));
+    // Verify sequential reads work as expected.
+    std::array<char, kLineWidth> buffer{};
+    std::int64_t size;
+    {
+      ASSERT_OK_AND_ASSIGN(auto actual, file->Read(kLineWidth));
+      EXPECT_EQ(lines[2 * i], actual->ToString());
+    }
+    {
+      ASSERT_OK_AND_ASSIGN(size, file->Read(buffer.size(), buffer.data()));
+      EXPECT_EQ(size, kLineWidth);
+      auto actual = std::string{buffer.begin(), buffer.end()};
+      EXPECT_EQ(lines[2 * i + 1], actual);
+    }
+
+    // Verify random reads interleave too.
+    auto const index = RandomIndex(kLineCount);
+    auto const position = index * kLineWidth;
+    ASSERT_OK_AND_ASSIGN(size, file->ReadAt(position, buffer.size(), buffer.data()));
+    EXPECT_EQ(size, kLineWidth);
+    auto actual = std::string{buffer.begin(), buffer.end()};
+    EXPECT_EQ(lines[index], actual);
+
+    // Verify random reads using buffers work.
+    ASSERT_OK_AND_ASSIGN(auto b, file->ReadAt(position, kLineWidth));
+    EXPECT_EQ(lines[index], b->ToString());
+  }
+}
+
+TEST_F(GcsIntegrationTest, OpenInputFileRandomSeek) {
+  auto fs = internal::MakeGcsFileSystemForTest(TestGcsOptions());
+
+  // Create a file large enough to make the random access tests non-trivial.
+  auto constexpr kLineWidth = 100;
+  auto constexpr kLineCount = 4096;
+  std::vector<std::string> lines(kLineCount);
+  int lineno = 0;
+  std::generate_n(lines.begin(), lines.size(),
+                  [&] { return RandomLine(++lineno, kLineWidth); });
+
+  const auto path =
+      kPreexistingBucket + std::string("/OpenInputFileRandomSeek/object-name");
+  std::shared_ptr<io::OutputStream> output;
+  ASSERT_OK_AND_ASSIGN(output, fs->OpenOutputStream(path, {}));
+  for (auto const& line : lines) {
+    ASSERT_OK(output->Write(line.data(), line.size()));
+  }
+  ASSERT_OK(output->Close());
+
+  std::shared_ptr<io::RandomAccessFile> file;
+  ASSERT_OK_AND_ASSIGN(file, fs->OpenInputFile(path));
+  for (int i = 0; i != 32; ++i) {
+    SCOPED_TRACE("Iteration " + std::to_string(i));
+    // Verify sequential reads work as expected.
+    auto const index = RandomIndex(kLineCount);
+    auto const position = index * kLineWidth;
+    ASSERT_OK(file->Seek(position));
+    ASSERT_OK_AND_ASSIGN(auto actual, file->Read(kLineWidth));
+    EXPECT_EQ(lines[index], actual->ToString());
+  }
+}
+
+TEST_F(GcsIntegrationTest, OpenInputFileInfo) {
+  auto fs = internal::MakeGcsFileSystemForTest(TestGcsOptions());
+
+  arrow::fs::FileInfo info;
+  ASSERT_OK_AND_ASSIGN(info, fs->GetFileInfo(PreexistingObjectPath()));
+
+  std::shared_ptr<io::RandomAccessFile> file;
+  ASSERT_OK_AND_ASSIGN(file, fs->OpenInputFile(info));
+
+  std::array<char, 1024> buffer{};
+  std::int64_t size;
+  auto constexpr kStart = 16;
+  ASSERT_OK_AND_ASSIGN(size, file->ReadAt(kStart, buffer.size(), buffer.data()));
+
+  auto const expected = std::string(kLoremIpsum).substr(kStart);
+  EXPECT_EQ(std::string(buffer.data(), size), expected);
+}
+
+TEST_F(GcsIntegrationTest, OpenInputFileNotFound) {
+  auto fs = internal::MakeGcsFileSystemForTest(TestGcsOptions());
+
+  ASSERT_RAISES(IOError, fs->OpenInputFile(NotFoundObjectPath()));
+}
+
+TEST_F(GcsIntegrationTest, OpenInputFileInfoInvalid) {
+  auto fs = internal::MakeGcsFileSystemForTest(TestGcsOptions());
+
+  arrow::fs::FileInfo info;
+  ASSERT_OK_AND_ASSIGN(info, fs->GetFileInfo(kPreexistingBucket));
+  ASSERT_RAISES(IOError, fs->OpenInputFile(info));
+
+  ASSERT_OK_AND_ASSIGN(info, fs->GetFileInfo(NotFoundObjectPath()));
+  ASSERT_RAISES(IOError, fs->OpenInputFile(info));
+}
+
 }  // namespace
 }  // namespace fs
 }  // namespace arrow
diff --git a/cpp/src/arrow/flight/serialization_internal.cc b/cpp/src/arrow/flight/serialization_internal.cc
index 36c6cc9e623..c0a84359977 100644
--- a/cpp/src/arrow/flight/serialization_internal.cc
+++ b/cpp/src/arrow/flight/serialization_internal.cc
@@ -276,7 +276,7 @@ grpc::Status FlightDataSerialize(const FlightPayload& msg, ByteBuffer* out,
 
         // Write padding if not multiple of 8
         const auto remainder = static_cast<int>(
-            BitUtil::RoundUpToMultipleOf8(buffer->size()) - buffer->size());
+            bit_util::RoundUpToMultipleOf8(buffer->size()) - buffer->size());
         if (remainder) {
           slices.push_back(grpc::Slice(kPaddingBytes, remainder));
         }
diff --git a/cpp/src/arrow/io/memory_benchmark.cc b/cpp/src/arrow/io/memory_benchmark.cc
index fbb34f38654..6af1807d161 100644
--- a/cpp/src/arrow/io/memory_benchmark.cc
+++ b/cpp/src/arrow/io/memory_benchmark.cc
@@ -49,10 +49,10 @@ using VectorType = __m512i;
 #define VectorSet _mm512_set1_epi32
 #define VectorLoad _mm512_stream_load_si512
 #define VectorLoadAsm(SRC, DST) \
-  asm volatile("vmovaps %[src], %[dst]" : [ dst ] "=v"(DST) : [ src ] "m"(SRC) :)
+  asm volatile("vmovaps %[src], %[dst]" : [dst] "=v"(DST) : [src] "m"(SRC) :)
 #define VectorStreamLoad _mm512_stream_load_si512
 #define VectorStreamLoadAsm(SRC, DST) \
-  asm volatile("vmovntdqa %[src], %[dst]" : [ dst ] "=v"(DST) : [ src ] "m"(SRC) :)
+  asm volatile("vmovntdqa %[src], %[dst]" : [dst] "=v"(DST) : [src] "m"(SRC) :)
 #define VectorStreamWrite _mm512_stream_si512
 
 #else
@@ -63,10 +63,10 @@ using VectorType = __m256i;
 #define VectorSet _mm256_set1_epi32
 #define VectorLoad _mm256_stream_load_si256
 #define VectorLoadAsm(SRC, DST) \
-  asm volatile("vmovaps %[src], %[dst]" : [ dst ] "=v"(DST) : [ src ] "m"(SRC) :)
+  asm volatile("vmovaps %[src], %[dst]" : [dst] "=v"(DST) : [src] "m"(SRC) :)
 #define VectorStreamLoad _mm256_stream_load_si256
 #define VectorStreamLoadAsm(SRC, DST) \
-  asm volatile("vmovntdqa %[src], %[dst]" : [ dst ] "=v"(DST) : [ src ] "m"(SRC) :)
+  asm volatile("vmovntdqa %[src], %[dst]" : [dst] "=v"(DST) : [src] "m"(SRC) :)
 #define VectorStreamWrite _mm256_stream_si256
 
 #else  // ARROW_HAVE_AVX2 not set
@@ -75,10 +75,10 @@ using VectorType = __m128i;
 #define VectorSet _mm_set1_epi32
 #define VectorLoad _mm_stream_load_si128
 #define VectorLoadAsm(SRC, DST) \
-  asm volatile("movaps %[src], %[dst]" : [ dst ] "=x"(DST) : [ src ] "m"(SRC) :)
+  asm volatile("movaps %[src], %[dst]" : [dst] "=x"(DST) : [src] "m"(SRC) :)
 #define VectorStreamLoad _mm_stream_load_si128
 #define VectorStreamLoadAsm(SRC, DST) \
-  asm volatile("movntdqa %[src], %[dst]" : [ dst ] "=x"(DST) : [ src ] "m"(SRC) :)
+  asm volatile("movntdqa %[src], %[dst]" : [dst] "=x"(DST) : [src] "m"(SRC) :)
 #define VectorStreamWrite _mm_stream_si128
 
 #endif  // ARROW_HAVE_AVX2
@@ -164,14 +164,14 @@ using VectorTypeDual = uint8x16x2_t;
 
 static void armv8_stream_load_pair(VectorType* src, VectorType* dst) {
   asm volatile("LDNP %[reg1], %[reg2], [%[from]]\n\t"
-               : [ reg1 ] "+r"(*dst), [ reg2 ] "+r"(*(dst + 1))
-               : [ from ] "r"(src));
+               : [reg1] "+r"(*dst), [reg2] "+r"(*(dst + 1))
+               : [from] "r"(src));
 }
 
 static void armv8_stream_store_pair(VectorType* src, VectorType* dst) {
   asm volatile("STNP %[reg1], %[reg2], [%[to]]\n\t"
-               : [ to ] "+r"(dst)
-               : [ reg1 ] "r"(*src), [ reg2 ] "r"(*(src + 1))
+               : [to] "+r"(dst)
+               : [reg1] "r"(*src), [reg2] "r"(*(src + 1))
                : "memory");
 }
 
@@ -179,7 +179,7 @@ static void armv8_stream_ldst_pair(VectorType* src, VectorType* dst) {
   asm volatile(
       "LDNP q1, q2, [%[from]]\n\t"
       "STNP q1, q2, [%[to]]\n\t"
-      : [ from ] "+r"(src), [ to ] "+r"(dst)
+      : [from] "+r"(src), [to] "+r"(dst)
       :
       : "memory", "v0", "v1", "v2", "v3");
 }
diff --git a/cpp/src/arrow/io/memory_test.cc b/cpp/src/arrow/io/memory_test.cc
index bd62761c739..50335cb6ac8 100644
--- a/cpp/src/arrow/io/memory_test.cc
+++ b/cpp/src/arrow/io/memory_test.cc
@@ -430,7 +430,7 @@ struct DoublingTransform {
 struct SwappingTransform {
   // A transform that swaps every pair of bytes
   Result<std::shared_ptr<Buffer>> operator()(const std::shared_ptr<Buffer>& buf) {
-    int64_t dest_size = BitUtil::RoundDown(buf->size() + has_pending_, 2);
+    int64_t dest_size = bit_util::RoundDown(buf->size() + has_pending_, 2);
     ARROW_ASSIGN_OR_RAISE(auto dest, AllocateBuffer(dest_size));
     const uint8_t* data = buf->data();
     uint8_t* out_data = dest->mutable_data();
diff --git a/cpp/src/arrow/ipc/feather.cc b/cpp/src/arrow/ipc/feather.cc
index 26051de042d..977c0b4b534 100644
--- a/cpp/src/arrow/ipc/feather.cc
+++ b/cpp/src/arrow/ipc/feather.cc
@@ -283,7 +283,7 @@ class ReaderV1 : public Reader {
 
     // If there are nulls, the null bitmask is first
     if (meta->null_count() > 0) {
-      int64_t null_bitmap_size = GetOutputLength(BitUtil::BytesForBits(meta->length()));
+      int64_t null_bitmap_size = GetOutputLength(bit_util::BytesForBits(meta->length()));
       buffers.push_back(SliceBuffer(buffer, offset, null_bitmap_size));
       offset += null_bitmap_size;
     } else {
@@ -560,7 +560,7 @@ struct ArrayWriterV1 {
           prim_values.values()->data() + (prim_values.offset() * fw_type.bit_width() / 8);
       int64_t bit_offset = (prim_values.offset() * fw_type.bit_width()) % 8;
       return WriteBuffer(buffer,
-                         BitUtil::BytesForBits(values.length() * fw_type.bit_width()),
+                         bit_util::BytesForBits(values.length() * fw_type.bit_width()),
                          bit_offset);
     } else {
       return Status::OK();
@@ -608,7 +608,8 @@ struct ArrayWriterV1 {
     // Write the null bitmask
     if (values.null_count() > 0) {
       RETURN_NOT_OK(WriteBuffer(values.null_bitmap_data(),
-                                BitUtil::BytesForBits(values.length()), values.offset()));
+                                bit_util::BytesForBits(values.length()),
+                                values.offset()));
     }
     // Write data buffer(s)
     return VisitTypeInline(*values.type(), this);
diff --git a/cpp/src/arrow/ipc/message.cc b/cpp/src/arrow/ipc/message.cc
index ab20897e861..c256e42c3d0 100644
--- a/cpp/src/arrow/ipc/message.cc
+++ b/cpp/src/arrow/ipc/message.cc
@@ -532,7 +532,7 @@ Status WriteMessage(const Buffer& message, const IpcWriteOptions& options,
 
   // Write the flatbuffer size prefix including padding in little endian
   int32_t padded_flatbuffer_size =
-      BitUtil::ToLittleEndian(padded_message_length - prefix_size);
+      bit_util::ToLittleEndian(padded_message_length - prefix_size);
   RETURN_NOT_OK(file->Write(&padded_flatbuffer_size, sizeof(int32_t)));
 
   // Write the flatbuffer
@@ -684,18 +684,18 @@ class MessageDecoder::MessageDecoderImpl {
   }
 
   Status ConsumeInitialData(const uint8_t* data, int64_t size) {
-    return ConsumeInitial(BitUtil::FromLittleEndian(util::SafeLoadAs<int32_t>(data)));
+    return ConsumeInitial(bit_util::FromLittleEndian(util::SafeLoadAs<int32_t>(data)));
   }
 
   Status ConsumeInitialBuffer(const std::shared_ptr<Buffer>& buffer) {
     ARROW_ASSIGN_OR_RAISE(auto continuation, ConsumeDataBufferInt32(buffer));
-    return ConsumeInitial(BitUtil::FromLittleEndian(continuation));
+    return ConsumeInitial(bit_util::FromLittleEndian(continuation));
   }
 
   Status ConsumeInitialChunks() {
     int32_t continuation = 0;
     RETURN_NOT_OK(ConsumeDataChunks(sizeof(int32_t), &continuation));
-    return ConsumeInitial(BitUtil::FromLittleEndian(continuation));
+    return ConsumeInitial(bit_util::FromLittleEndian(continuation));
   }
 
   Status ConsumeInitial(int32_t continuation) {
@@ -724,18 +724,18 @@ class MessageDecoder::MessageDecoderImpl {
 
   Status ConsumeMetadataLengthData(const uint8_t* data, int64_t size) {
     return ConsumeMetadataLength(
-        BitUtil::FromLittleEndian(util::SafeLoadAs<int32_t>(data)));
+        bit_util::FromLittleEndian(util::SafeLoadAs<int32_t>(data)));
   }
 
   Status ConsumeMetadataLengthBuffer(const std::shared_ptr<Buffer>& buffer) {
     ARROW_ASSIGN_OR_RAISE(auto metadata_length, ConsumeDataBufferInt32(buffer));
-    return ConsumeMetadataLength(BitUtil::FromLittleEndian(metadata_length));
+    return ConsumeMetadataLength(bit_util::FromLittleEndian(metadata_length));
   }
 
   Status ConsumeMetadataLengthChunks() {
     int32_t metadata_length = 0;
     RETURN_NOT_OK(ConsumeDataChunks(sizeof(int32_t), &metadata_length));
-    return ConsumeMetadataLength(BitUtil::FromLittleEndian(metadata_length));
+    return ConsumeMetadataLength(bit_util::FromLittleEndian(metadata_length));
   }
 
   Status ConsumeMetadataLength(int32_t metadata_length) {
diff --git a/cpp/src/arrow/ipc/metadata_internal.cc b/cpp/src/arrow/ipc/metadata_internal.cc
index 1873bbca962..0ce0270a866 100644
--- a/cpp/src/arrow/ipc/metadata_internal.cc
+++ b/cpp/src/arrow/ipc/metadata_internal.cc
@@ -1303,15 +1303,15 @@ Status WriteFileFooter(const Schema& schema, const std::vector<FileBlock>& dicti
 
 #ifndef NDEBUG
   for (size_t i = 0; i < dictionaries.size(); ++i) {
-    DCHECK(BitUtil::IsMultipleOf8(dictionaries[i].offset)) << i;
-    DCHECK(BitUtil::IsMultipleOf8(dictionaries[i].metadata_length)) << i;
-    DCHECK(BitUtil::IsMultipleOf8(dictionaries[i].body_length)) << i;
+    DCHECK(bit_util::IsMultipleOf8(dictionaries[i].offset)) << i;
+    DCHECK(bit_util::IsMultipleOf8(dictionaries[i].metadata_length)) << i;
+    DCHECK(bit_util::IsMultipleOf8(dictionaries[i].body_length)) << i;
   }
 
   for (size_t i = 0; i < record_batches.size(); ++i) {
-    DCHECK(BitUtil::IsMultipleOf8(record_batches[i].offset)) << i;
-    DCHECK(BitUtil::IsMultipleOf8(record_batches[i].metadata_length)) << i;
-    DCHECK(BitUtil::IsMultipleOf8(record_batches[i].body_length)) << i;
+    DCHECK(bit_util::IsMultipleOf8(record_batches[i].offset)) << i;
+    DCHECK(bit_util::IsMultipleOf8(record_batches[i].metadata_length)) << i;
+    DCHECK(bit_util::IsMultipleOf8(record_batches[i].body_length)) << i;
   }
 #endif
 
diff --git a/cpp/src/arrow/ipc/read_write_test.cc b/cpp/src/arrow/ipc/read_write_test.cc
index f1c893cb49b..3c7f9f9cefc 100644
--- a/cpp/src/arrow/ipc/read_write_test.cc
+++ b/cpp/src/arrow/ipc/read_write_test.cc
@@ -133,14 +133,14 @@ TEST_P(TestMessage, SerializeTo) {
     int64_t output_length = 0;
     ASSERT_OK_AND_ASSIGN(auto stream, io::BufferOutputStream::Create(1 << 10));
     ASSERT_OK(message->SerializeTo(stream.get(), options_, &output_length));
-    ASSERT_EQ(BitUtil::RoundUp(metadata->size() + prefix_size, alignment) + body_length,
+    ASSERT_EQ(bit_util::RoundUp(metadata->size() + prefix_size, alignment) + body_length,
               output_length);
     ASSERT_OK_AND_EQ(output_length, stream->Tell());
     ASSERT_OK_AND_ASSIGN(auto buffer, stream->Finish());
     // chech whether length is written in little endian
     auto buffer_ptr = buffer.get()->data();
     ASSERT_EQ(output_length - body_length - prefix_size,
-              BitUtil::FromLittleEndian(*(uint32_t*)(buffer_ptr + 4)));
+              bit_util::FromLittleEndian(*(uint32_t*)(buffer_ptr + 4)));
   };
 
   CheckWithAlignment(8);
@@ -2642,7 +2642,7 @@ void GetReadRecordBatchReadRanges(
   // read magic and footer length IO
   auto file_end_size = magic_size + sizeof(int32_t);
   auto footer_length_offset = buffer->size() - file_end_size;
-  auto footer_length = BitUtil::FromLittleEndian(
+  auto footer_length = bit_util::FromLittleEndian(
       util::SafeLoadAs<int32_t>(buffer->data() + footer_length_offset));
   ASSERT_EQ(read_ranges[0].length, file_end_size);
   // read footer IO
diff --git a/cpp/src/arrow/ipc/reader.cc b/cpp/src/arrow/ipc/reader.cc
index e9d85ff6088..b834aa429c1 100644
--- a/cpp/src/arrow/ipc/reader.cc
+++ b/cpp/src/arrow/ipc/reader.cc
@@ -160,7 +160,7 @@ class ArrayLoader {
       return Status::Invalid("Negative length for reading buffer ", buffer_index_);
     }
     // This construct permits overriding GetBuffer at compile time
-    if (!BitUtil::IsMultipleOf8(offset)) {
+    if (!bit_util::IsMultipleOf8(offset)) {
       return Status::Invalid("Buffer ", buffer_index_,
                              " did not start on 8-byte aligned offset: ", offset);
     }
@@ -412,7 +412,7 @@ Result<std::shared_ptr<Buffer>> DecompressBuffer(const std::shared_ptr<Buffer>&
 
   const uint8_t* data = buf->data();
   int64_t compressed_size = buf->size() - sizeof(int64_t);
-  int64_t uncompressed_size = BitUtil::FromLittleEndian(util::SafeLoadAs<int64_t>(data));
+  int64_t uncompressed_size = bit_util::FromLittleEndian(util::SafeLoadAs<int64_t>(data));
 
   ARROW_ASSIGN_OR_RAISE(auto uncompressed,
                         AllocateBuffer(uncompressed_size, options.memory_pool));
@@ -971,9 +971,9 @@ static inline FileBlock FileBlockFromFlatbuffer(const flatbuf::Block* block) {
 static Result<std::unique_ptr<Message>> ReadMessageFromBlock(
     const FileBlock& block, io::RandomAccessFile* file,
     const FieldsLoaderFunction& fields_loader) {
-  if (!BitUtil::IsMultipleOf8(block.offset) ||
-      !BitUtil::IsMultipleOf8(block.metadata_length) ||
-      !BitUtil::IsMultipleOf8(block.body_length)) {
+  if (!bit_util::IsMultipleOf8(block.offset) ||
+      !bit_util::IsMultipleOf8(block.metadata_length) ||
+      !bit_util::IsMultipleOf8(block.body_length)) {
     return Status::Invalid("Unaligned block in IPC file");
   }
 
@@ -987,9 +987,9 @@ static Result<std::unique_ptr<Message>> ReadMessageFromBlock(
 
 static Future<std::shared_ptr<Message>> ReadMessageFromBlockAsync(
     const FileBlock& block, io::RandomAccessFile* file, const io::IOContext& io_context) {
-  if (!BitUtil::IsMultipleOf8(block.offset) ||
-      !BitUtil::IsMultipleOf8(block.metadata_length) ||
-      !BitUtil::IsMultipleOf8(block.body_length)) {
+  if (!bit_util::IsMultipleOf8(block.offset) ||
+      !bit_util::IsMultipleOf8(block.metadata_length) ||
+      !bit_util::IsMultipleOf8(block.body_length)) {
     return Status::Invalid("Unaligned block in IPC file");
   }
 
@@ -1280,7 +1280,7 @@ class RecordBatchFileReaderImpl : public RecordBatchFileReader {
             return Status::Invalid("Not an Arrow file");
           }
 
-          int32_t footer_length = BitUtil::FromLittleEndian(
+          int32_t footer_length = bit_util::FromLittleEndian(
               *reinterpret_cast<const int32_t*>(buffer->data()));
 
           if (footer_length <= 0 ||
@@ -1841,7 +1841,7 @@ Status ReadSparseTensorMetadata(const Buffer& metadata,
   *out_fb_sparse_tensor = sparse_tensor;
 
   auto buffer = sparse_tensor->data();
-  if (!BitUtil::IsMultipleOf8(buffer->offset())) {
+  if (!bit_util::IsMultipleOf8(buffer->offset())) {
     return Status::Invalid(
         "Buffer of sparse index data did not start on 8-byte aligned offset: ",
         buffer->offset());
diff --git a/cpp/src/arrow/ipc/tensor_test.cc b/cpp/src/arrow/ipc/tensor_test.cc
index 7af1492f624..7e013fe3925 100644
--- a/cpp/src/arrow/ipc/tensor_test.cc
+++ b/cpp/src/arrow/ipc/tensor_test.cc
@@ -153,9 +153,9 @@ class TestSparseTensorRoundTrip : public BaseTensorTest {
     const auto& sparse_index =
         checked_cast<const SparseCOOIndex&>(*sparse_tensor.sparse_index());
     const int64_t indices_length =
-        BitUtil::RoundUpToMultipleOf8(index_elem_size * sparse_index.indices()->size());
+        bit_util::RoundUpToMultipleOf8(index_elem_size * sparse_index.indices()->size());
     const int64_t data_length =
-        BitUtil::RoundUpToMultipleOf8(elem_size * sparse_tensor.non_zero_length());
+        bit_util::RoundUpToMultipleOf8(elem_size * sparse_tensor.non_zero_length());
     const int64_t expected_body_length = indices_length + data_length;
     ASSERT_EQ(expected_body_length, body_length);
 
@@ -194,11 +194,11 @@ class TestSparseTensorRoundTrip : public BaseTensorTest {
     const auto& sparse_index =
         checked_cast<const SparseIndexType&>(*sparse_tensor.sparse_index());
     const int64_t indptr_length =
-        BitUtil::RoundUpToMultipleOf8(index_elem_size * sparse_index.indptr()->size());
+        bit_util::RoundUpToMultipleOf8(index_elem_size * sparse_index.indptr()->size());
     const int64_t indices_length =
-        BitUtil::RoundUpToMultipleOf8(index_elem_size * sparse_index.indices()->size());
+        bit_util::RoundUpToMultipleOf8(index_elem_size * sparse_index.indices()->size());
     const int64_t data_length =
-        BitUtil::RoundUpToMultipleOf8(elem_size * sparse_tensor.non_zero_length());
+        bit_util::RoundUpToMultipleOf8(elem_size * sparse_tensor.non_zero_length());
     const int64_t expected_body_length = indptr_length + indices_length + data_length;
     ASSERT_EQ(expected_body_length, body_length);
 
@@ -240,15 +240,15 @@ class TestSparseTensorRoundTrip : public BaseTensorTest {
     int64_t indices_length = 0;
 
     for (int64_t i = 0; i < ndim - 1; ++i) {
-      indptr_length += BitUtil::RoundUpToMultipleOf8(index_elem_size *
-                                                     sparse_index.indptr()[i]->size());
+      indptr_length += bit_util::RoundUpToMultipleOf8(index_elem_size *
+                                                      sparse_index.indptr()[i]->size());
     }
     for (int64_t i = 0; i < ndim; ++i) {
-      indices_length += BitUtil::RoundUpToMultipleOf8(index_elem_size *
-                                                      sparse_index.indices()[i]->size());
+      indices_length += bit_util::RoundUpToMultipleOf8(index_elem_size *
+                                                       sparse_index.indices()[i]->size());
     }
     const int64_t data_length =
-        BitUtil::RoundUpToMultipleOf8(elem_size * sparse_tensor.non_zero_length());
+        bit_util::RoundUpToMultipleOf8(elem_size * sparse_tensor.non_zero_length());
     const int64_t expected_body_length = indptr_length + indices_length + data_length;
     ASSERT_EQ(expected_body_length, body_length);
 
@@ -264,11 +264,11 @@ class TestSparseTensorRoundTrip : public BaseTensorTest {
     int64_t out_indptr_length = 0;
     int64_t out_indices_length = 0;
     for (int i = 0; i < ndim - 1; ++i) {
-      out_indptr_length += BitUtil::RoundUpToMultipleOf8(
+      out_indptr_length += bit_util::RoundUpToMultipleOf8(
           index_elem_size * resulted_sparse_index.indptr()[i]->size());
     }
     for (int i = 0; i < ndim; ++i) {
-      out_indices_length += BitUtil::RoundUpToMultipleOf8(
+      out_indices_length += bit_util::RoundUpToMultipleOf8(
           index_elem_size * resulted_sparse_index.indices()[i]->size());
     }
 
diff --git a/cpp/src/arrow/ipc/writer.cc b/cpp/src/arrow/ipc/writer.cc
index 7b9254b7e59..3515027175a 100644
--- a/cpp/src/arrow/ipc/writer.cc
+++ b/cpp/src/arrow/ipc/writer.cc
@@ -89,7 +89,7 @@ Status GetTruncatedBitmap(int64_t offset, int64_t length,
     *buffer = input;
     return Status::OK();
   }
-  int64_t min_length = PaddedLength(BitUtil::BytesForBits(length));
+  int64_t min_length = PaddedLength(bit_util::BytesForBits(length));
   if (offset != 0 || min_length < input->size()) {
     // With a sliced array / non-zero offset, we must copy the bitmap
     ARROW_ASSIGN_OR_RAISE(*buffer, CopyBitmap(pool, input->data(), offset, length));
@@ -192,7 +192,7 @@ class RecordBatchSerializer {
                           codec->Compress(buffer.size(), buffer.data(), maximum_length,
                                           result->mutable_data() + sizeof(int64_t)));
     *reinterpret_cast<int64_t*>(result->mutable_data()) =
-        BitUtil::ToLittleEndian(buffer.size());
+        bit_util::ToLittleEndian(buffer.size());
     *out = SliceBuffer(std::move(result), /*offset=*/0, actual_length + sizeof(int64_t));
     return Status::OK();
   }
@@ -243,7 +243,7 @@ class RecordBatchSerializer {
       // The buffer might be null if we are handling zero row lengths.
       if (buffer) {
         size = buffer->size();
-        padding = BitUtil::RoundUpToMultipleOf8(size) - size;
+        padding = bit_util::RoundUpToMultipleOf8(size) - size;
       }
 
       buffer_meta_.push_back({offset, size});
@@ -251,7 +251,7 @@ class RecordBatchSerializer {
     }
 
     out_->body_length = offset - buffer_start_offset_;
-    DCHECK(BitUtil::IsMultipleOf8(out_->body_length));
+    DCHECK(bit_util::IsMultipleOf8(out_->body_length));
 
     // Now that we have computed the locations of all of the buffers in shared
     // memory, the data header can be converted to a flatbuffer and written out
@@ -326,7 +326,7 @@ class RecordBatchSerializer {
 
       // Send padding if it's available
       const int64_t buffer_length =
-          std::min(BitUtil::RoundUpToMultipleOf8(array.length() * type_width),
+          std::min(bit_util::RoundUpToMultipleOf8(array.length() * type_width),
                    data->size() - byte_offset);
       data = SliceBuffer(data, byte_offset, buffer_length);
     }
@@ -585,7 +585,7 @@ Status WriteIpcPayload(const IpcPayload& payload, const IpcWriteOptions& options
     // The buffer might be null if we are handling zero row lengths.
     if (buffer) {
       size = buffer->size();
-      padding = BitUtil::RoundUpToMultipleOf8(size) - size;
+      padding = bit_util::RoundUpToMultipleOf8(size) - size;
     }
 
     if (size > 0) {
@@ -825,13 +825,13 @@ class SparseTensorSerializer {
     for (size_t i = 0; i < out_->body_buffers.size(); ++i) {
       const Buffer* buffer = out_->body_buffers[i].get();
       int64_t size = buffer->size();
-      int64_t padding = BitUtil::RoundUpToMultipleOf8(size) - size;
+      int64_t padding = bit_util::RoundUpToMultipleOf8(size) - size;
       buffer_meta_.push_back({offset, size + padding});
       offset += size + padding;
     }
 
     out_->body_length = offset - buffer_start_offset_;
-    DCHECK(BitUtil::IsMultipleOf8(out_->body_length));
+    DCHECK(bit_util::IsMultipleOf8(out_->body_length));
 
     return SerializeMetadata(sparse_tensor);
   }
@@ -1282,7 +1282,7 @@ class PayloadFileWriter : public internal::IpcPayloadWriter, protected StreamBoo
     }
 
     // write footer length in little endian
-    footer_length = BitUtil::ToLittleEndian(footer_length);
+    footer_length = bit_util::ToLittleEndian(footer_length);
     RETURN_NOT_OK(Write(&footer_length, sizeof(int32_t)));
 
     // Write magic bytes to end file
diff --git a/cpp/src/arrow/memory_pool.cc b/cpp/src/arrow/memory_pool.cc
index c80e8f6f680..cf8bf64b271 100644
--- a/cpp/src/arrow/memory_pool.cc
+++ b/cpp/src/arrow/memory_pool.cc
@@ -710,7 +710,7 @@ class PoolBuffer final : public ResizableBuffer {
     }
     uint8_t* ptr = mutable_data();
     if (!ptr || capacity > capacity_) {
-      int64_t new_capacity = BitUtil::RoundUpToMultipleOf64(capacity);
+      int64_t new_capacity = bit_util::RoundUpToMultipleOf64(capacity);
       if (ptr) {
         RETURN_NOT_OK(pool_->Reallocate(capacity_, new_capacity, &ptr));
       } else {
@@ -730,7 +730,7 @@ class PoolBuffer final : public ResizableBuffer {
     if (ptr && shrink_to_fit && new_size <= size_) {
       // Buffer is non-null and is not growing, so shrink to the requested size without
       // excess space.
-      int64_t new_capacity = BitUtil::RoundUpToMultipleOf64(new_size);
+      int64_t new_capacity = bit_util::RoundUpToMultipleOf64(new_size);
       if (capacity_ != new_capacity) {
         // Buffer hasn't got yet the requested size.
         RETURN_NOT_OK(pool_->Reallocate(capacity_, new_capacity, &ptr));
diff --git a/cpp/src/arrow/public_api_test.cc b/cpp/src/arrow/public_api_test.cc
index 2a0728e1be0..f6f78295499 100644
--- a/cpp/src/arrow/public_api_test.cc
+++ b/cpp/src/arrow/public_api_test.cc
@@ -62,6 +62,10 @@
 #error "ASSIGN_OR_RAISE should not be visible from Arrow public headers."
 #endif
 
+#ifdef OPENTELEMETRY_VERSION
+#error "OpenTelemetry should not be visible from Arrow public headers."
+#endif
+
 #ifdef XSIMD_VERSION_MAJOR
 #error "xsimd should not be visible from Arrow public headers."
 #endif
diff --git a/cpp/src/arrow/python/numpy_to_arrow.cc b/cpp/src/arrow/python/numpy_to_arrow.cc
index 0bcfee163a2..5b4c12ab030 100644
--- a/cpp/src/arrow/python/numpy_to_arrow.cc
+++ b/cpp/src/arrow/python/numpy_to_arrow.cc
@@ -75,7 +75,7 @@ namespace {
 
 Status AllocateNullBitmap(MemoryPool* pool, int64_t length,
                           std::shared_ptr<ResizableBuffer>* out) {
-  int64_t null_bytes = BitUtil::BytesForBits(length);
+  int64_t null_bytes = bit_util::BytesForBits(length);
   ARROW_ASSIGN_OR_RAISE(auto null_bitmap, AllocateResizableBuffer(null_bytes, pool));
 
   // Padding zeroed by AllocateResizableBuffer
@@ -99,7 +99,7 @@ inline int64_t ValuesToBitmap(PyArrayObject* arr, uint8_t* bitmap) {
     if (traits::isnull(values[i])) {
       ++null_count;
     } else {
-      BitUtil::SetBit(bitmap, i);
+      bit_util::SetBit(bitmap, i);
     }
   }
 
@@ -163,9 +163,9 @@ int64_t MaskToBitmap(PyArrayObject* mask, int64_t length, uint8_t* bitmap) {
   for (int i = 0; i < length; ++i) {
     if (mask_values[i]) {
       ++null_count;
-      BitUtil::ClearBit(bitmap, i);
+      bit_util::ClearBit(bitmap, i);
     } else {
-      BitUtil::SetBit(bitmap, i);
+      bit_util::SetBit(bitmap, i);
     }
   }
   return null_count;
@@ -434,7 +434,7 @@ inline Status NumPyConverter::PrepareInputData(std::shared_ptr<Buffer>* data) {
   }
 
   if (dtype_->type_num == NPY_BOOL) {
-    int64_t nbytes = BitUtil::BytesForBits(length_);
+    int64_t nbytes = bit_util::BytesForBits(length_);
     ARROW_ASSIGN_OR_RAISE(auto buffer, AllocateBuffer(nbytes, pool_));
 
     Ndarray1DIndexer<uint8_t> values(arr_);
@@ -824,7 +824,7 @@ Status NumPyConverter::Visit(const StructType& type) {
                                    // byte offset
                                    null_offset / 8,
                                    // byte size
-                                   BitUtil::BytesForBits(null_data->length));
+                                   bit_util::BytesForBits(null_data->length));
     } else {
       ARROW_ASSIGN_OR_RAISE(
           fixed_null_buffer,
diff --git a/cpp/src/arrow/symbols.map b/cpp/src/arrow/symbols.map
index 7262cc6a898..79f6ac50818 100644
--- a/cpp/src/arrow/symbols.map
+++ b/cpp/src/arrow/symbols.map
@@ -24,6 +24,11 @@
       # (from e.g. STL or Flatbuffers) involving Arrow types.
       *arrow::*;
       *arrow_vendored::*;
+      # OpenTelemetry requires on shared global state for features
+      # like automatic span linking. If we hide its symbols, spans
+      # started in (say) libarrow_dataset don't link up with those
+      # started in libarrow and vice versa.
+      *opentelemetry::*;
     };
     # Also export C-level helpers
     arrow_*;
diff --git a/cpp/src/arrow/testing/gtest_common.h b/cpp/src/arrow/testing/gtest_common.h
index 8b48238ed8a..b3f25d10e32 100644
--- a/cpp/src/arrow/testing/gtest_common.h
+++ b/cpp/src/arrow/testing/gtest_common.h
@@ -43,12 +43,12 @@ class TestBase : public ::testing::Test {
   }
 
   std::shared_ptr<Buffer> MakeRandomNullBitmap(int64_t length, int64_t null_count) {
-    const int64_t null_nbytes = BitUtil::BytesForBits(length);
+    const int64_t null_nbytes = bit_util::BytesForBits(length);
 
     std::shared_ptr<Buffer> null_bitmap = *AllocateBuffer(null_nbytes, pool_);
     memset(null_bitmap->mutable_data(), 255, null_nbytes);
     for (int64_t i = 0; i < null_count; i++) {
-      BitUtil::ClearBit(null_bitmap->mutable_data(), i * (length / null_count));
+      bit_util::ClearBit(null_bitmap->mutable_data(), i * (length / null_count));
     }
     return null_bitmap;
   }
diff --git a/cpp/src/arrow/testing/gtest_util.cc b/cpp/src/arrow/testing/gtest_util.cc
index f471ed140a0..0517be236dc 100644
--- a/cpp/src/arrow/testing/gtest_util.cc
+++ b/cpp/src/arrow/testing/gtest_util.cc
@@ -569,9 +569,9 @@ std::shared_ptr<Array> TweakValidityBit(const std::shared_ptr<Array>& array,
   auto data = array->data()->Copy();
   if (data->buffers[0] == nullptr) {
     data->buffers[0] = *AllocateBitmap(data->length);
-    BitUtil::SetBitsTo(data->buffers[0]->mutable_data(), 0, data->length, true);
+    bit_util::SetBitsTo(data->buffers[0]->mutable_data(), 0, data->length, true);
   }
-  BitUtil::SetBitTo(data->buffers[0]->mutable_data(), index, validity);
+  bit_util::SetBitTo(data->buffers[0]->mutable_data(), index, validity);
   data->null_count = kUnknownNullCount;
   // Need to return a new array, because Array caches the null bitmap pointer
   return MakeArray(data);
diff --git a/cpp/src/arrow/testing/gtest_util.h b/cpp/src/arrow/testing/gtest_util.h
index e7faea72101..b3d8ce877e8 100644
--- a/cpp/src/arrow/testing/gtest_util.h
+++ b/cpp/src/arrow/testing/gtest_util.h
@@ -464,7 +464,7 @@ static inline Status GetBitmapFromVector(const std::vector<T>& is_valid,
   uint8_t* bitmap = buffer->mutable_data();
   for (size_t i = 0; i < static_cast<size_t>(length); ++i) {
     if (is_valid[i]) {
-      BitUtil::SetBit(bitmap, i);
+      bit_util::SetBit(bitmap, i);
     }
   }
 
diff --git a/cpp/src/arrow/testing/json_internal.cc b/cpp/src/arrow/testing/json_internal.cc
index 5e5d67a3fc6..4c0ca7d8926 100644
--- a/cpp/src/arrow/testing/json_internal.cc
+++ b/cpp/src/arrow/testing/json_internal.cc
@@ -1566,7 +1566,7 @@ class ArrayReader {
     data_->null_count = 0;
     for (int64_t i = 0; i < length; ++i) {
       if (is_valid_[i]) {
-        BitUtil::SetBit(bitmap, i);
+        bit_util::SetBit(bitmap, i);
       } else {
         ++data_->null_count;
       }
diff --git a/cpp/src/arrow/testing/random.cc b/cpp/src/arrow/testing/random.cc
index ce6ec1a6e67..cbf9edfde3c 100644
--- a/cpp/src/arrow/testing/random.cc
+++ b/cpp/src/arrow/testing/random.cc
@@ -107,7 +107,7 @@ struct GenerateOptions {
 
     for (size_t i = 0; i < n; i++) {
       if (dist(rng)) {
-        BitUtil::SetBit(buffer, i);
+        bit_util::SetBit(buffer, i);
       } else {
         count++;
       }
@@ -458,8 +458,8 @@ std::shared_ptr<Array> GenerateOffsets(SeedType seed, int64_t size,
   options.GenerateBitmap(null_bitmap, size, &null_count);
   // Make sure the first and last entry are non-null
   for (const int64_t offset : std::vector<int64_t>{0, size - 1}) {
-    if (!arrow::BitUtil::GetBit(null_bitmap, offset)) {
-      arrow::BitUtil::SetBit(null_bitmap, offset);
+    if (!arrow::bit_util::GetBit(null_bitmap, offset)) {
+      arrow::bit_util::SetBit(null_bitmap, offset);
       --null_count;
     }
   }
@@ -507,8 +507,8 @@ std::shared_ptr<Array> OffsetsFromLengthsArray(OffsetArrayType* lengths,
   buffers[0] = *AllocateEmptyBitmap(size);
   uint8_t* null_bitmap = buffers[0]->mutable_data();
   // Make sure the first and last entry are non-null
-  arrow::BitUtil::SetBit(null_bitmap, 0);
-  arrow::BitUtil::SetBit(null_bitmap, size - 1);
+  arrow::bit_util::SetBit(null_bitmap, 0);
+  arrow::bit_util::SetBit(null_bitmap, size - 1);
 
   buffers[1] = *AllocateBuffer(sizeof(typename OffsetArrayType::value_type) * size);
   auto data =
@@ -517,7 +517,7 @@ std::shared_ptr<Array> OffsetsFromLengthsArray(OffsetArrayType* lengths,
   int index = 1;
   for (const auto& length : *lengths) {
     if (length.has_value()) {
-      arrow::BitUtil::SetBit(null_bitmap, index);
+      arrow::bit_util::SetBit(null_bitmap, index);
       data[index] = data[index - 1] + *length;
       DCHECK_GE(*length, 0);
     } else {
diff --git a/cpp/src/arrow/testing/uniform_real.h b/cpp/src/arrow/testing/uniform_real.h
index 155cb16b641..8aa04a83288 100644
--- a/cpp/src/arrow/testing/uniform_real.h
+++ b/cpp/src/arrow/testing/uniform_real.h
@@ -39,7 +39,7 @@ namespace detail {
 template <typename RealType, typename Rng>
 RealType generate_canonical(Rng& rng) {
   const size_t b = std::numeric_limits<RealType>::digits;
-  const size_t log2R = 63 - ::arrow::BitUtil::CountLeadingZeros(
+  const size_t log2R = 63 - ::arrow::bit_util::CountLeadingZeros(
                                 static_cast<uint64_t>(Rng::max() - Rng::min()) + 1);
   const size_t k = b / log2R + (b % log2R != 0) + (b == 0);
   const RealType r = static_cast<RealType>(Rng::max() - Rng::min()) + 1;
diff --git a/cpp/src/arrow/testing/util.cc b/cpp/src/arrow/testing/util.cc
index 41297804884..19917185130 100644
--- a/cpp/src/arrow/testing/util.cc
+++ b/cpp/src/arrow/testing/util.cc
@@ -38,8 +38,8 @@
 #endif
 
 #include "arrow/table.h"
-#include "arrow/type.h"
 #include "arrow/testing/random.h"
+#include "arrow/type.h"
 #include "arrow/util/io_util.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/pcg_random.h"
diff --git a/cpp/src/arrow/type_traits.h b/cpp/src/arrow/type_traits.h
index 5e4c975d3a2..4b4cb5d15d3 100644
--- a/cpp/src/arrow/type_traits.h
+++ b/cpp/src/arrow/type_traits.h
@@ -110,7 +110,7 @@ struct TypeTraits<BooleanType> {
   using CType = bool;
 
   static constexpr int64_t bytes_required(int64_t elements) {
-    return BitUtil::BytesForBits(elements);
+    return bit_util::BytesForBits(elements);
   }
   constexpr static bool is_parameter_free = true;
   static inline std::shared_ptr<DataType> type_singleton() { return boolean(); }
diff --git a/cpp/src/arrow/util/align_util.h b/cpp/src/arrow/util/align_util.h
index 4c25a1a17b8..cffad0198d3 100644
--- a/cpp/src/arrow/util/align_util.h
+++ b/cpp/src/arrow/util/align_util.h
@@ -41,7 +41,7 @@ struct BitmapWordAlignParams {
 template <uint64_t ALIGN_IN_BYTES>
 inline BitmapWordAlignParams BitmapWordAlign(const uint8_t* data, int64_t bit_offset,
                                              int64_t length) {
-  static_assert(BitUtil::IsPowerOf2(ALIGN_IN_BYTES),
+  static_assert(bit_util::IsPowerOf2(ALIGN_IN_BYTES),
                 "ALIGN_IN_BYTES should be a positive power of two");
   constexpr uint64_t ALIGN_IN_BITS = ALIGN_IN_BYTES * 8;
 
@@ -52,7 +52,7 @@ inline BitmapWordAlignParams BitmapWordAlign(const uint8_t* data, int64_t bit_of
   // difference between both addresses.
   const uint64_t bit_addr =
       reinterpret_cast<size_t>(data) * 8 + static_cast<uint64_t>(bit_offset);
-  const uint64_t aligned_bit_addr = BitUtil::RoundUpToPowerOf2(bit_addr, ALIGN_IN_BITS);
+  const uint64_t aligned_bit_addr = bit_util::RoundUpToPowerOf2(bit_addr, ALIGN_IN_BITS);
 
   p.leading_bits = std::min<int64_t>(length, aligned_bit_addr - bit_addr);
   p.aligned_words = (length - p.leading_bits) / ALIGN_IN_BITS;
diff --git a/cpp/src/arrow/util/aligned_storage.h b/cpp/src/arrow/util/aligned_storage.h
index f6acb36c95a..213d8c72e48 100644
--- a/cpp/src/arrow/util/aligned_storage.h
+++ b/cpp/src/arrow/util/aligned_storage.h
@@ -33,13 +33,16 @@ class AlignedStorage {
   static constexpr bool can_memcpy = std::is_trivial<T>::value;
 
 #if __cpp_constexpr >= 201304L  // non-const constexpr
-  constexpr T* get() noexcept { return launder(reinterpret_cast<T*>(&data_)); }
+  constexpr T* get() noexcept {
+    return arrow::internal::launder(reinterpret_cast<T*>(&data_));
+  }
 #else
-  T* get() noexcept { return launder(reinterpret_cast<T*>(&data_)); }
+  T* get() noexcept { return arrow::internal::launder(reinterpret_cast<T*>(&data_)); }
 #endif
 
   constexpr const T* get() const noexcept {
-    return launder(reinterpret_cast<const T*>(&data_));
+    // Use fully qualified name to avoid ambiguities with MSVC (ARROW-14800)
+    return arrow::internal::launder(reinterpret_cast<const T*>(&data_));
   }
 
   void destroy() noexcept {
diff --git a/cpp/src/arrow/util/basic_decimal.cc b/cpp/src/arrow/util/basic_decimal.cc
index c3b9d0272e8..0fbed2c47da 100644
--- a/cpp/src/arrow/util/basic_decimal.cc
+++ b/cpp/src/arrow/util/basic_decimal.cc
@@ -122,7 +122,7 @@ static const BasicDecimal128 ScaleMultipliersHalf[] = {
     BasicDecimal128(2710505431213761085LL, 343699775700336640ULL)};
 
 #define BasicDecimal256FromLE(v1, v2, v3, v4) \
-  BasicDecimal256(BitUtil::LittleEndianArray::ToNative<uint64_t, 4>(v1, v2, v3, v4))
+  BasicDecimal256(bit_util::little_endian::ToNative<uint64_t, 4>(v1, v2, v3, v4))
 
 static const BasicDecimal256 ScaleMultipliersDecimal256[] = {
     BasicDecimal256FromLE({1ULL, 0ULL, 0ULL, 0ULL}),
@@ -605,9 +605,9 @@ template <int N>
 inline void MultiplyUnsignedArray(const std::array<uint64_t, N>& lh,
                                   const std::array<uint64_t, N>& rh,
                                   std::array<uint64_t, N>* result) {
-  const auto lh_le = BitUtil::LittleEndianArray::Make(lh);
-  const auto rh_le = BitUtil::LittleEndianArray::Make(rh);
-  auto result_le = BitUtil::LittleEndianArray::Make(result);
+  const auto lh_le = bit_util::little_endian::Make(lh);
+  const auto rh_le = bit_util::little_endian::Make(rh);
+  auto result_le = bit_util::little_endian::Make(result);
 
   for (int j = 0; j < N; ++j) {
     uint64_t carry = 0;
@@ -649,7 +649,7 @@ BasicDecimal128& BasicDecimal128::operator*=(const BasicDecimal128& right) {
 template <size_t N>
 static int64_t FillInArray(const std::array<uint64_t, N>& value_array,
                            uint32_t* result_array) {
-  const auto value_array_le = BitUtil::LittleEndianArray::Make(value_array);
+  const auto value_array_le = bit_util::little_endian::Make(value_array);
   int64_t next_index = 0;
   // 1st loop to find out 1st non-negative value in input
   int64_t i = N - 1;
@@ -786,7 +786,7 @@ static DecimalStatus BuildFromArray(std::array<uint64_t, N>* result_array,
   }
   int64_t next_index = length - 1;
   size_t i = 0;
-  auto result_array_le = BitUtil::LittleEndianArray::Make(result_array);
+  auto result_array_le = bit_util::little_endian::Make(result_array);
   for (; i < N && next_index >= 0; i++) {
     uint64_t lower_bits = array[next_index--];
     result_array_le[i] =
@@ -808,7 +808,7 @@ static DecimalStatus BuildFromArray(BasicDecimal128* value, const uint32_t* arra
   if (status != DecimalStatus::kSuccess) {
     return status;
   }
-  const auto result_array_le = BitUtil::LittleEndianArray::Make(result_array);
+  const auto result_array_le = bit_util::little_endian::Make(result_array);
   *value = {static_cast<int64_t>(result_array_le[1]), result_array_le[0]};
   return DecimalStatus::kSuccess;
 }
@@ -893,7 +893,7 @@ static inline DecimalStatus DecimalDivide(const DecimalClass& dividend,
   // Normalize by shifting both by a multiple of 2 so that
   // the digit guessing is better. The requirement is that
   // divisor_array[0] is greater than 2**31.
-  int64_t normalize_bits = BitUtil::CountLeadingZeros(divisor_array[0]);
+  int64_t normalize_bits = bit_util::CountLeadingZeros(divisor_array[0]);
   ShiftArrayLeft(divisor_array, divisor_length, normalize_bits);
   ShiftArrayLeft(dividend_array, dividend_length, normalize_bits);
 
@@ -1158,9 +1158,9 @@ int32_t BasicDecimal128::CountLeadingBinaryZeros() const {
   DCHECK_GE(*this, BasicDecimal128(0));
 
   if (high_bits_ == 0) {
-    return BitUtil::CountLeadingZeros(low_bits_) + 64;
+    return bit_util::CountLeadingZeros(low_bits_) + 64;
   } else {
-    return BitUtil::CountLeadingZeros(static_cast<uint64_t>(high_bits_));
+    return bit_util::CountLeadingZeros(static_cast<uint64_t>(high_bits_));
   }
 }
 
@@ -1175,7 +1175,7 @@ constexpr int BasicDecimal256::kMaxPrecision;
 constexpr int BasicDecimal256::kMaxScale;
 
 BasicDecimal256& BasicDecimal256::Negate() {
-  auto array_le = BitUtil::LittleEndianArray::Make(&array_);
+  auto array_le = bit_util::little_endian::Make(&array_);
   uint64_t carry = 1;
   for (size_t i = 0; i < array_.size(); ++i) {
     uint64_t& elem = array_le[i];
@@ -1193,8 +1193,8 @@ BasicDecimal256 BasicDecimal256::Abs(const BasicDecimal256& in) {
 }
 
 BasicDecimal256& BasicDecimal256::operator+=(const BasicDecimal256& right) {
-  auto array_le = BitUtil::LittleEndianArray::Make(&array_);
-  const auto right_array_le = BitUtil::LittleEndianArray::Make(right.array_);
+  auto array_le = bit_util::little_endian::Make(&array_);
+  const auto right_array_le = bit_util::little_endian::Make(right.array_);
   uint64_t carry = 0;
   for (size_t i = 0; i < array_.size(); i++) {
     const uint64_t right_value = right_array_le[i];
@@ -1227,7 +1227,7 @@ BasicDecimal256& BasicDecimal256::operator<<=(uint32_t bits) {
     return *this;
   }
   uint32_t in_word_shift = bits % 64;
-  auto array_le = BitUtil::LittleEndianArray::Make(&array_);
+  auto array_le = bit_util::little_endian::Make(&array_);
   for (int i = static_cast<int>(array_.size() - 1); i >= cross_word_shift; i--) {
     // Account for shifts larger then 64 bits
     array_le[i] = array_le[i - cross_word_shift];
@@ -1349,13 +1349,13 @@ BasicDecimal256 operator*(const BasicDecimal256& left, const BasicDecimal256& ri
 }
 
 bool operator<(const BasicDecimal256& left, const BasicDecimal256& right) {
-  const auto lhs_le = BitUtil::LittleEndianArray::Make(left.native_endian_array());
-  const auto rhs_le = BitUtil::LittleEndianArray::Make(right.native_endian_array());
+  const auto lhs_le = bit_util::little_endian::Make(left.native_endian_array());
+  const auto rhs_le = bit_util::little_endian::Make(right.native_endian_array());
   return lhs_le[3] != rhs_le[3]
              ? static_cast<int64_t>(lhs_le[3]) < static_cast<int64_t>(rhs_le[3])
-             : lhs_le[2] != rhs_le[2] ? lhs_le[2] < rhs_le[2]
-                                      : lhs_le[1] != rhs_le[1] ? lhs_le[1] < rhs_le[1]
-                                                               : lhs_le[0] < rhs_le[0];
+         : lhs_le[2] != rhs_le[2] ? lhs_le[2] < rhs_le[2]
+         : lhs_le[1] != rhs_le[1] ? lhs_le[1] < rhs_le[1]
+                                  : lhs_le[0] < rhs_le[0];
 }
 
 BasicDecimal256 operator-(const BasicDecimal256& operand) {
diff --git a/cpp/src/arrow/util/basic_decimal.h b/cpp/src/arrow/util/basic_decimal.h
index 93dced967e3..00514194155 100644
--- a/cpp/src/arrow/util/basic_decimal.h
+++ b/cpp/src/arrow/util/basic_decimal.h
@@ -76,7 +76,7 @@ class ARROW_EXPORT BasicDecimal128 {
   ///
   /// Input array is assumed to be in little endianness, with native endian elements.
   BasicDecimal128(LittleEndianArrayTag, const std::array<uint64_t, 2>& array) noexcept
-      : BasicDecimal128(BitUtil::LittleEndianArray::ToNative(array)) {}
+      : BasicDecimal128(bit_util::little_endian::ToNative(array)) {}
 
   /// \brief Empty constructor creates a BasicDecimal128 with a value of 0.
   constexpr BasicDecimal128() noexcept : BasicDecimal128(0, 0) {}
@@ -300,7 +300,7 @@ class ARROW_EXPORT BasicDecimal256 {
   ///
   /// Input array is assumed to be in little endianness, with native endian elements.
   BasicDecimal256(LittleEndianArrayTag, const std::array<uint64_t, 4>& array) noexcept
-      : BasicDecimal256(BitUtil::LittleEndianArray::ToNative(array)) {}
+      : BasicDecimal256(bit_util::little_endian::ToNative(array)) {}
 
   /// \brief Empty constructor creates a BasicDecimal256 with a value of 0.
   constexpr BasicDecimal256() noexcept : array_({0, 0, 0, 0}) {}
@@ -310,12 +310,12 @@ class ARROW_EXPORT BasicDecimal256 {
             typename = typename std::enable_if<
                 std::is_integral<T>::value && (sizeof(T) <= sizeof(uint64_t)), T>::type>
   constexpr BasicDecimal256(T value) noexcept
-      : array_(BitUtil::LittleEndianArray::ToNative<uint64_t, 4>(
+      : array_(bit_util::little_endian::ToNative<uint64_t, 4>(
             {static_cast<uint64_t>(value), extend(value), extend(value),
              extend(value)})) {}
 
   explicit BasicDecimal256(const BasicDecimal128& value) noexcept
-      : array_(BitUtil::LittleEndianArray::ToNative<uint64_t, 4>(
+      : array_(bit_util::little_endian::ToNative<uint64_t, 4>(
             {value.low_bits(), static_cast<uint64_t>(value.high_bits()),
              extend(value.high_bits()), extend(value.high_bits())})) {}
 
@@ -357,7 +357,7 @@ class ARROW_EXPORT BasicDecimal256 {
   /// uint64_t element are in native endian order.
   /// For example, BasicDecimal256(123).little_endian_array() = {123, 0};
   inline const std::array<uint64_t, 4> little_endian_array() const {
-    return BitUtil::LittleEndianArray::FromNative(array_);
+    return bit_util::little_endian::FromNative(array_);
   }
 
   inline const uint8_t* native_endian_bytes() const {
@@ -369,7 +369,7 @@ class ARROW_EXPORT BasicDecimal256 {
   }
 
   /// \brief Get the lowest bits of the two's complement representation of the number.
-  inline uint64_t low_bits() const { return BitUtil::LittleEndianArray::Make(array_)[0]; }
+  inline uint64_t low_bits() const { return bit_util::little_endian::Make(array_)[0]; }
 
   /// \brief Return the raw bytes of the value in native-endian byte order.
   std::array<uint8_t, 32> ToBytes() const;
@@ -400,11 +400,11 @@ class ARROW_EXPORT BasicDecimal256 {
   bool FitsInPrecision(int32_t precision) const;
 
   inline int64_t Sign() const {
-    return 1 | (static_cast<int64_t>(BitUtil::LittleEndianArray::Make(array_)[3]) >> 63);
+    return 1 | (static_cast<int64_t>(bit_util::little_endian::Make(array_)[3]) >> 63);
   }
 
   inline int64_t IsNegative() const {
-    return static_cast<int64_t>(BitUtil::LittleEndianArray::Make(array_)[3]) < 0;
+    return static_cast<int64_t>(bit_util::little_endian::Make(array_)[3]) < 0;
   }
 
   /// \brief Multiply this number by another number. The result is truncated to 256 bits.
diff --git a/cpp/src/arrow/util/bit_block_counter.h b/cpp/src/arrow/util/bit_block_counter.h
index 9d3a75a5a31..d254638dbf3 100644
--- a/cpp/src/arrow/util/bit_block_counter.h
+++ b/cpp/src/arrow/util/bit_block_counter.h
@@ -35,7 +35,7 @@ namespace internal {
 namespace detail {
 
 inline uint64_t LoadWord(const uint8_t* bytes) {
-  return BitUtil::ToLittleEndian(util::SafeLoadAs<uint64_t>(bytes));
+  return bit_util::ToLittleEndian(util::SafeLoadAs<uint64_t>(bytes));
 }
 
 inline uint64_t ShiftWord(uint64_t current, uint64_t next, int64_t shift) {
@@ -132,10 +132,10 @@ class ARROW_EXPORT BitBlockCounter {
       if (bits_remaining_ < kFourWordsBits) {
         return GetBlockSlow(kFourWordsBits);
       }
-      total_popcount += BitUtil::PopCount(LoadWord(bitmap_));
-      total_popcount += BitUtil::PopCount(LoadWord(bitmap_ + 8));
-      total_popcount += BitUtil::PopCount(LoadWord(bitmap_ + 16));
-      total_popcount += BitUtil::PopCount(LoadWord(bitmap_ + 24));
+      total_popcount += bit_util::PopCount(LoadWord(bitmap_));
+      total_popcount += bit_util::PopCount(LoadWord(bitmap_ + 8));
+      total_popcount += bit_util::PopCount(LoadWord(bitmap_ + 16));
+      total_popcount += bit_util::PopCount(LoadWord(bitmap_ + 24));
     } else {
       // When the offset is > 0, we need there to be a word beyond the last
       // aligned word in the bitmap for the bit shifting logic.
@@ -144,18 +144,18 @@ class ARROW_EXPORT BitBlockCounter {
       }
       auto current = LoadWord(bitmap_);
       auto next = LoadWord(bitmap_ + 8);
-      total_popcount += BitUtil::PopCount(ShiftWord(current, next, offset_));
+      total_popcount += bit_util::PopCount(ShiftWord(current, next, offset_));
       current = next;
       next = LoadWord(bitmap_ + 16);
-      total_popcount += BitUtil::PopCount(ShiftWord(current, next, offset_));
+      total_popcount += bit_util::PopCount(ShiftWord(current, next, offset_));
       current = next;
       next = LoadWord(bitmap_ + 24);
-      total_popcount += BitUtil::PopCount(ShiftWord(current, next, offset_));
+      total_popcount += bit_util::PopCount(ShiftWord(current, next, offset_));
       current = next;
       next = LoadWord(bitmap_ + 32);
-      total_popcount += BitUtil::PopCount(ShiftWord(current, next, offset_));
+      total_popcount += bit_util::PopCount(ShiftWord(current, next, offset_));
     }
-    bitmap_ += BitUtil::BytesForBits(kFourWordsBits);
+    bitmap_ += bit_util::BytesForBits(kFourWordsBits);
     bits_remaining_ -= kFourWordsBits;
     return {256, static_cast<int16_t>(total_popcount)};
   }
@@ -177,15 +177,15 @@ class ARROW_EXPORT BitBlockCounter {
       if (bits_remaining_ < kWordBits) {
         return GetBlockSlow(kWordBits);
       }
-      popcount = BitUtil::PopCount(LoadWord(bitmap_));
+      popcount = bit_util::PopCount(LoadWord(bitmap_));
     } else {
       // When the offset is > 0, we need there to be a word beyond the last
       // aligned word in the bitmap for the bit shifting logic.
       if (bits_remaining_ < 2 * kWordBits - offset_) {
         return GetBlockSlow(kWordBits);
       }
-      popcount =
-          BitUtil::PopCount(ShiftWord(LoadWord(bitmap_), LoadWord(bitmap_ + 8), offset_));
+      popcount = bit_util::PopCount(
+          ShiftWord(LoadWord(bitmap_), LoadWord(bitmap_ + 8), offset_));
     }
     bitmap_ += kWordBits / 8;
     bits_remaining_ -= kWordBits;
@@ -305,8 +305,8 @@ class ARROW_EXPORT BinaryBitBlockCounter {
           static_cast<int16_t>(std::min(bits_remaining_, kWordBits));
       int16_t popcount = 0;
       for (int64_t i = 0; i < run_length; ++i) {
-        if (Op<bool>::Call(BitUtil::GetBit(left_bitmap_, left_offset_ + i),
-                           BitUtil::GetBit(right_bitmap_, right_offset_ + i))) {
+        if (Op<bool>::Call(bit_util::GetBit(left_bitmap_, left_offset_ + i),
+                           bit_util::GetBit(right_bitmap_, right_offset_ + i))) {
           ++popcount;
         }
       }
@@ -320,14 +320,14 @@ class ARROW_EXPORT BinaryBitBlockCounter {
 
     int64_t popcount = 0;
     if (left_offset_ == 0 && right_offset_ == 0) {
-      popcount = BitUtil::PopCount(
+      popcount = bit_util::PopCount(
           Op<uint64_t>::Call(LoadWord(left_bitmap_), LoadWord(right_bitmap_)));
     } else {
       auto left_word =
           ShiftWord(LoadWord(left_bitmap_), LoadWord(left_bitmap_ + 8), left_offset_);
       auto right_word =
           ShiftWord(LoadWord(right_bitmap_), LoadWord(right_bitmap_ + 8), right_offset_);
-      popcount = BitUtil::PopCount(Op<uint64_t>::Call(left_word, right_word));
+      popcount = bit_util::PopCount(Op<uint64_t>::Call(left_word, right_word));
     }
     left_bitmap_ += kWordBits / 8;
     right_bitmap_ += kWordBits / 8;
@@ -448,7 +448,7 @@ static Status VisitBitBlocks(const std::shared_ptr<Buffer>& bitmap_buf, int64_t
       }
     } else {
       for (int64_t i = 0; i < block.length; ++i, ++position) {
-        if (BitUtil::GetBit(bitmap, offset + position)) {
+        if (bit_util::GetBit(bitmap, offset + position)) {
           ARROW_RETURN_NOT_OK(visit_not_null(position));
         } else {
           ARROW_RETURN_NOT_OK(visit_null());
@@ -481,7 +481,7 @@ static void VisitBitBlocksVoid(const std::shared_ptr<Buffer>& bitmap_buf, int64_
       }
     } else {
       for (int64_t i = 0; i < block.length; ++i, ++position) {
-        if (BitUtil::GetBit(bitmap, offset + position)) {
+        if (bit_util::GetBit(bitmap, offset + position)) {
           visit_not_null(position);
         } else {
           visit_null();
@@ -527,8 +527,8 @@ static Status VisitTwoBitBlocks(const std::shared_ptr<Buffer>& left_bitmap_buf,
       }
     } else {
       for (int64_t i = 0; i < block.length; ++i, ++position) {
-        if (BitUtil::GetBit(left_bitmap, left_offset + position) &&
-            BitUtil::GetBit(right_bitmap, right_offset + position)) {
+        if (bit_util::GetBit(left_bitmap, left_offset + position) &&
+            bit_util::GetBit(right_bitmap, right_offset + position)) {
           ARROW_RETURN_NOT_OK(visit_not_null(position));
         } else {
           ARROW_RETURN_NOT_OK(visit_null());
@@ -575,8 +575,8 @@ static void VisitTwoBitBlocksVoid(const std::shared_ptr<Buffer>& left_bitmap_buf
       }
     } else {
       for (int64_t i = 0; i < block.length; ++i, ++position) {
-        if (BitUtil::GetBit(left_bitmap, left_offset + position) &&
-            BitUtil::GetBit(right_bitmap, right_offset + position)) {
+        if (bit_util::GetBit(left_bitmap, left_offset + position) &&
+            bit_util::GetBit(right_bitmap, right_offset + position)) {
           visit_not_null(position);
         } else {
           visit_null();
diff --git a/cpp/src/arrow/util/bit_block_counter_benchmark.cc b/cpp/src/arrow/util/bit_block_counter_benchmark.cc
index 429993442a3..c08fcfdb604 100644
--- a/cpp/src/arrow/util/bit_block_counter_benchmark.cc
+++ b/cpp/src/arrow/util/bit_block_counter_benchmark.cc
@@ -77,7 +77,7 @@ struct UnaryBitBlockBenchmark {
         } else if (block.popcount > 0) {
           // Some but not all not-null
           for (int64_t i = 0; i < block.length; ++i) {
-            if (BitUtil::GetBit(bitmap, position + i)) {
+            if (bit_util::GetBit(bitmap, position + i)) {
               result += int8_arr.Value(position + i);
             }
           }
@@ -165,8 +165,8 @@ struct BinaryBitBlockBenchmark {
         } else if (block.popcount > 0) {
           // Some but not all not-null
           for (int64_t i = 0; i < block.length; ++i) {
-            if (BitUtil::GetBit(left_bitmap, position + i) &&
-                BitUtil::GetBit(right_bitmap, position + i)) {
+            if (bit_util::GetBit(left_bitmap, position + i) &&
+                bit_util::GetBit(right_bitmap, position + i)) {
               result += left_int8->Value(position + i) + right_int8->Value(position + i);
             }
           }
diff --git a/cpp/src/arrow/util/bit_block_counter_test.cc b/cpp/src/arrow/util/bit_block_counter_test.cc
index 3fdfa3ed9cb..80ceeb885e6 100644
--- a/cpp/src/arrow/util/bit_block_counter_test.cc
+++ b/cpp/src/arrow/util/bit_block_counter_test.cc
@@ -106,13 +106,13 @@ TEST_F(TestBitBlockCounter, OneWordWithOffsets) {
     ASSERT_EQ(block.popcount, 64);
 
     // Add a false value to the next word
-    BitUtil::SetBitTo(buf_->mutable_data(), kWordSize + offset, false);
+    bit_util::SetBitTo(buf_->mutable_data(), kWordSize + offset, false);
     block = counter_->NextWord();
     ASSERT_EQ(block.length, 64);
     ASSERT_EQ(block.popcount, 63);
 
     // Set the next word to all false
-    BitUtil::SetBitsTo(buf_->mutable_data(), 2 * kWordSize + offset, kWordSize, false);
+    bit_util::SetBitsTo(buf_->mutable_data(), 2 * kWordSize + offset, kWordSize, false);
 
     block = counter_->NextWord();
     ASSERT_EQ(block.length, 64);
@@ -150,17 +150,17 @@ TEST_F(TestBitBlockCounter, FourWordsWithOffsets) {
     ASSERT_EQ(block.popcount, block.length);
 
     // Add some false values to the next 3 shifted words
-    BitUtil::SetBitTo(buf_->mutable_data(), 4 * kWordSize + offset, false);
-    BitUtil::SetBitTo(buf_->mutable_data(), 5 * kWordSize + offset, false);
-    BitUtil::SetBitTo(buf_->mutable_data(), 6 * kWordSize + offset, false);
+    bit_util::SetBitTo(buf_->mutable_data(), 4 * kWordSize + offset, false);
+    bit_util::SetBitTo(buf_->mutable_data(), 5 * kWordSize + offset, false);
+    bit_util::SetBitTo(buf_->mutable_data(), 6 * kWordSize + offset, false);
     block = counter_->NextFourWords();
 
     ASSERT_EQ(block.length, 4 * kWordSize);
     ASSERT_EQ(block.popcount, 253);
 
     // Set the next two words to all false
-    BitUtil::SetBitsTo(buf_->mutable_data(), 8 * kWordSize + offset, 2 * kWordSize,
-                       false);
+    bit_util::SetBitsTo(buf_->mutable_data(), 8 * kWordSize + offset, 2 * kWordSize,
+                        false);
 
     // Block is half set
     block = counter_->NextFourWords();
@@ -224,8 +224,8 @@ void CheckBinaryBitBlockOp(NextWordFunc&& get_next_word) {
       int expected_popcount = 0;
       for (int j = 0; j < block.length; ++j) {
         expected_popcount += static_cast<int>(
-            Op<bool>::Call(BitUtil::GetBit(left->data(), position + left_offset + j),
-                           BitUtil::GetBit(right->data(), position + right_offset + j)));
+            Op<bool>::Call(bit_util::GetBit(left->data(), position + left_offset + j),
+                           bit_util::GetBit(right->data(), position + right_offset + j)));
       }
       ASSERT_EQ(block.popcount, expected_popcount);
       position += block.length;
diff --git a/cpp/src/arrow/util/bit_run_reader.cc b/cpp/src/arrow/util/bit_run_reader.cc
index eda6088eb32..b1284151d5c 100644
--- a/cpp/src/arrow/util/bit_run_reader.cc
+++ b/cpp/src/arrow/util/bit_run_reader.cc
@@ -38,14 +38,14 @@ BitRunReader::BitRunReader(const uint8_t* bitmap, int64_t start_offset, int64_t
   // On the initial load if there is an offset we need to account for this when
   // loading bytes.  Every other call to LoadWord() should only occur when
   // position_ is a multiple of 64.
-  current_run_bit_set_ = !BitUtil::GetBit(bitmap, start_offset);
+  current_run_bit_set_ = !bit_util::GetBit(bitmap, start_offset);
   int64_t bits_remaining = length + position_;
 
   LoadWord(bits_remaining);
 
   // Prepare for inversion in NextRun.
   // Clear out any preceding bits.
-  word_ = word_ & ~BitUtil::LeastSignificantBitMask(position_);
+  word_ = word_ & ~bit_util::LeastSignificantBitMask(position_);
 }
 
 #endif
diff --git a/cpp/src/arrow/util/bit_run_reader.h b/cpp/src/arrow/util/bit_run_reader.h
index ed9f4fa867a..a436a50b86f 100644
--- a/cpp/src/arrow/util/bit_run_reader.h
+++ b/cpp/src/arrow/util/bit_run_reader.h
@@ -102,13 +102,13 @@ class ARROW_EXPORT BitRunReader {
     int64_t start_bit_offset = start_position & 63;
     // Invert the word for proper use of CountTrailingZeros and
     // clear bits so CountTrailingZeros can do it magic.
-    word_ = ~word_ & ~BitUtil::LeastSignificantBitMask(start_bit_offset);
+    word_ = ~word_ & ~bit_util::LeastSignificantBitMask(start_bit_offset);
 
     // Go  forward until the next change from unset to set.
-    int64_t new_bits = BitUtil::CountTrailingZeros(word_) - start_bit_offset;
+    int64_t new_bits = bit_util::CountTrailingZeros(word_) - start_bit_offset;
     position_ += new_bits;
 
-    if (ARROW_PREDICT_FALSE(BitUtil::IsMultipleOf64(position_)) &&
+    if (ARROW_PREDICT_FALSE(bit_util::IsMultipleOf64(position_)) &&
         ARROW_PREDICT_TRUE(position_ < length_)) {
       // Continue extending position while we can advance an entire word.
       // (updates position_ accordingly).
@@ -125,10 +125,10 @@ class ARROW_EXPORT BitRunReader {
       // Advance the position of the bitmap for loading.
       bitmap_ += sizeof(uint64_t);
       LoadNextWord();
-      new_bits = BitUtil::CountTrailingZeros(word_);
+      new_bits = bit_util::CountTrailingZeros(word_);
       // Continue calculating run length.
       position_ += new_bits;
-    } while (ARROW_PREDICT_FALSE(BitUtil::IsMultipleOf64(position_)) &&
+    } while (ARROW_PREDICT_FALSE(bit_util::IsMultipleOf64(position_)) &&
              ARROW_PREDICT_TRUE(position_ < length_) && new_bits > 0);
   }
 
@@ -141,13 +141,13 @@ class ARROW_EXPORT BitRunReader {
     if (ARROW_PREDICT_TRUE(bits_remaining >= 64)) {
       std::memcpy(&word_, bitmap_, 8);
     } else {
-      int64_t bytes_to_load = BitUtil::BytesForBits(bits_remaining);
+      int64_t bytes_to_load = bit_util::BytesForBits(bits_remaining);
       auto word_ptr = reinterpret_cast<uint8_t*>(&word_);
       std::memcpy(word_ptr, bitmap_, bytes_to_load);
       // Ensure stoppage at last bit in bitmap by reversing the next higher
       // order bit.
-      BitUtil::SetBitTo(word_ptr, bits_remaining,
-                        !BitUtil::GetBit(word_ptr, bits_remaining - 1));
+      bit_util::SetBitTo(word_ptr, bits_remaining,
+                         !bit_util::GetBit(word_ptr, bits_remaining - 1));
     }
 
     // Two cases:
@@ -294,25 +294,25 @@ class BaseSetBitRunReader {
     if (!Reverse) {
       bitmap_ += 8;
     }
-    return BitUtil::ToLittleEndian(word);
+    return bit_util::ToLittleEndian(word);
   }
 
   uint64_t LoadPartialWord(int8_t bit_offset, int64_t num_bits) {
     assert(num_bits > 0);
     uint64_t word = 0;
-    const int64_t num_bytes = BitUtil::BytesForBits(num_bits);
+    const int64_t num_bytes = bit_util::BytesForBits(num_bits);
     if (Reverse) {
       // Read in the most significant bytes of the word
       bitmap_ -= num_bytes;
       memcpy(reinterpret_cast<char*>(&word) + 8 - num_bytes, bitmap_, num_bytes);
       // XXX MostSignificantBitmask
-      return (BitUtil::ToLittleEndian(word) << bit_offset) &
-             ~BitUtil::LeastSignificantBitMask(64 - num_bits);
+      return (bit_util::ToLittleEndian(word) << bit_offset) &
+             ~bit_util::LeastSignificantBitMask(64 - num_bits);
     } else {
       memcpy(&word, bitmap_, num_bytes);
       bitmap_ += num_bytes;
-      return (BitUtil::ToLittleEndian(word) >> bit_offset) &
-             BitUtil::LeastSignificantBitMask(num_bits);
+      return (bit_util::ToLittleEndian(word) >> bit_offset) &
+             bit_util::LeastSignificantBitMask(num_bits);
     }
   }
 
@@ -434,12 +434,12 @@ class BaseSetBitRunReader {
 
 template <>
 inline int BaseSetBitRunReader<false>::CountFirstZeros(uint64_t word) {
-  return BitUtil::CountTrailingZeros(word);
+  return bit_util::CountTrailingZeros(word);
 }
 
 template <>
 inline int BaseSetBitRunReader<true>::CountFirstZeros(uint64_t word) {
-  return BitUtil::CountLeadingZeros(word);
+  return bit_util::CountLeadingZeros(word);
 }
 
 template <>
diff --git a/cpp/src/arrow/util/bit_stream_utils.h b/cpp/src/arrow/util/bit_stream_utils.h
index 73b063925a1..3a9c05425d9 100644
--- a/cpp/src/arrow/util/bit_stream_utils.h
+++ b/cpp/src/arrow/util/bit_stream_utils.h
@@ -31,7 +31,7 @@
 #include "arrow/util/ubsan.h"
 
 namespace arrow {
-namespace BitUtil {
+namespace bit_util {
 
 /// Utility class to write bit/byte streams.  This class can write data to either be
 /// bit packed or byte aligned (and a single stream that has a mix of both).
@@ -53,7 +53,7 @@ class BitWriter {
   /// The number of current bytes written, including the current byte (i.e. may include a
   /// fraction of a byte). Includes buffered values.
   int bytes_written() const {
-    return byte_offset_ + static_cast<int>(BitUtil::BytesForBits(bit_offset_));
+    return byte_offset_ + static_cast<int>(bit_util::BytesForBits(bit_offset_));
   }
   uint8_t* buffer() const { return buffer_; }
   int buffer_len() const { return max_bytes_; }
@@ -119,7 +119,7 @@ class BitReader {
       : buffer_(buffer), max_bytes_(buffer_len), byte_offset_(0), bit_offset_(0) {
     int num_bytes = std::min(8, max_bytes_ - byte_offset_);
     memcpy(&buffered_values_, buffer_ + byte_offset_, num_bytes);
-    buffered_values_ = arrow::BitUtil::FromLittleEndian(buffered_values_);
+    buffered_values_ = arrow::bit_util::FromLittleEndian(buffered_values_);
   }
 
   BitReader()
@@ -136,7 +136,7 @@ class BitReader {
     bit_offset_ = 0;
     int num_bytes = std::min(8, max_bytes_ - byte_offset_);
     memcpy(&buffered_values_, buffer_ + byte_offset_, num_bytes);
-    buffered_values_ = arrow::BitUtil::FromLittleEndian(buffered_values_);
+    buffered_values_ = arrow::bit_util::FromLittleEndian(buffered_values_);
   }
 
   /// Gets the next value from the buffer.  Returns true if 'v' could be read or false if
@@ -181,7 +181,7 @@ class BitReader {
   /// byte (i.e., there may be an additional fraction of a byte).
   int bytes_left() {
     return max_bytes_ -
-           (byte_offset_ + static_cast<int>(BitUtil::BytesForBits(bit_offset_)));
+           (byte_offset_ + static_cast<int>(bit_util::BytesForBits(bit_offset_)));
   }
 
   /// Maximum byte length of a vlq encoded int
@@ -215,7 +215,7 @@ inline bool BitWriter::PutValue(uint64_t v, int num_bits) {
 
   if (ARROW_PREDICT_FALSE(bit_offset_ >= 64)) {
     // Flush buffered_values_ and write out bits of v that did not fit
-    buffered_values_ = arrow::BitUtil::ToLittleEndian(buffered_values_);
+    buffered_values_ = arrow::bit_util::ToLittleEndian(buffered_values_);
     memcpy(buffer_ + byte_offset_, &buffered_values_, 8);
     buffered_values_ = 0;
     byte_offset_ += 8;
@@ -227,9 +227,9 @@ inline bool BitWriter::PutValue(uint64_t v, int num_bits) {
 }
 
 inline void BitWriter::Flush(bool align) {
-  int num_bytes = static_cast<int>(BitUtil::BytesForBits(bit_offset_));
+  int num_bytes = static_cast<int>(bit_util::BytesForBits(bit_offset_));
   DCHECK_LE(byte_offset_ + num_bytes, max_bytes_);
-  auto buffered_values = arrow::BitUtil::ToLittleEndian(buffered_values_);
+  auto buffered_values = arrow::bit_util::ToLittleEndian(buffered_values_);
   memcpy(buffer_ + byte_offset_, &buffered_values, num_bytes);
 
   if (align) {
@@ -252,7 +252,7 @@ template <typename T>
 inline bool BitWriter::PutAligned(T val, int num_bytes) {
   uint8_t* ptr = GetNextBytePtr(num_bytes);
   if (ptr == NULL) return false;
-  val = arrow::BitUtil::ToLittleEndian(val);
+  val = arrow::bit_util::ToLittleEndian(val);
   memcpy(ptr, &val, num_bytes);
   return true;
 }
@@ -266,7 +266,7 @@ inline void ResetBufferedValues_(const uint8_t* buffer, int byte_offset,
   } else {
     memcpy(buffered_values, buffer + byte_offset, bytes_remaining);
   }
-  *buffered_values = arrow::BitUtil::FromLittleEndian(*buffered_values);
+  *buffered_values = arrow::bit_util::FromLittleEndian(*buffered_values);
 }
 
 template <typename T>
@@ -276,7 +276,7 @@ inline void GetValue_(int num_bits, T* v, int max_bytes, const uint8_t* buffer,
 #pragma warning(push)
 #pragma warning(disable : 4800)
 #endif
-  *v = static_cast<T>(BitUtil::TrailingBits(*buffered_values, *bit_offset + num_bits) >>
+  *v = static_cast<T>(bit_util::TrailingBits(*buffered_values, *bit_offset + num_bits) >>
                       *bit_offset);
 #ifdef _MSC_VER
 #pragma warning(pop)
@@ -296,7 +296,7 @@ inline void GetValue_(int num_bits, T* v, int max_bytes, const uint8_t* buffer,
       // if shift exponent(num_bits - *bit_offset) is not less than sizeof(T), *v will not
       // change and the following code may cause a runtime error that the shift exponent
       // is too large
-      *v = *v | static_cast<T>(BitUtil::TrailingBits(*buffered_values, *bit_offset)
+      *v = *v | static_cast<T>(bit_util::TrailingBits(*buffered_values, *bit_offset)
                                << (num_bits - *bit_offset));
     }
 #ifdef _MSC_VER
@@ -403,7 +403,7 @@ inline bool BitReader::GetAligned(int num_bytes, T* v) {
     return false;
   }
 
-  int bytes_read = static_cast<int>(BitUtil::BytesForBits(bit_offset_));
+  int bytes_read = static_cast<int>(bit_util::BytesForBits(bit_offset_));
   if (ARROW_PREDICT_FALSE(byte_offset_ + bytes_read + num_bytes > max_bytes_)) {
     return false;
   }
@@ -411,7 +411,7 @@ inline bool BitReader::GetAligned(int num_bytes, T* v) {
   // Advance byte_offset to next unread byte and read num_bytes
   byte_offset_ += bytes_read;
   memcpy(v, buffer_ + byte_offset_, num_bytes);
-  *v = arrow::BitUtil::FromLittleEndian(*v);
+  *v = arrow::bit_util::FromLittleEndian(*v);
   byte_offset_ += num_bytes;
 
   bit_offset_ = 0;
@@ -422,7 +422,7 @@ inline bool BitReader::GetAligned(int num_bytes, T* v) {
 
 inline bool BitReader::Advance(int64_t num_bits) {
   int64_t bits_required = bit_offset_ + num_bits;
-  int64_t bytes_required = BitUtil::BytesForBits(bits_required);
+  int64_t bytes_required = bit_util::BytesForBits(bits_required);
   if (ARROW_PREDICT_FALSE(bytes_required > max_bytes_ - byte_offset_)) {
     return false;
   }
@@ -519,5 +519,5 @@ inline bool BitReader::GetZigZagVlqInt(int64_t* v) {
   return true;
 }
 
-}  // namespace BitUtil
+}  // namespace bit_util
 }  // namespace arrow
diff --git a/cpp/src/arrow/util/bit_util.cc b/cpp/src/arrow/util/bit_util.cc
index aa78da76531..fab621f278d 100644
--- a/cpp/src/arrow/util/bit_util.cc
+++ b/cpp/src/arrow/util/bit_util.cc
@@ -23,7 +23,7 @@
 #include "arrow/util/logging.h"
 
 namespace arrow {
-namespace BitUtil {
+namespace bit_util {
 
 void SetBitsTo(uint8_t* bits, int64_t start_offset, int64_t length, bool bits_are_set) {
   if (length == 0) {
@@ -82,7 +82,7 @@ void SetBitmapImpl(uint8_t* data, int64_t offset, int64_t length) {
 
   constexpr uint8_t set_byte = value ? UINT8_MAX : 0;
 
-  auto prologue = static_cast<int32_t>(BitUtil::RoundUp(offset, 8) - offset);
+  auto prologue = static_cast<int32_t>(bit_util::RoundUp(offset, 8) - offset);
   DCHECK_LT(prologue, 8);
 
   if (length < prologue) {  // special case where a mask is required
@@ -92,28 +92,28 @@ void SetBitmapImpl(uint8_t* data, int64_t offset, int64_t length) {
     //         mask --> |111|
     //                  |<---->|
     //                     pro
-    uint8_t mask = BitUtil::kPrecedingBitmask[8 - prologue] ^
-                   BitUtil::kPrecedingBitmask[8 - prologue + length];
+    uint8_t mask = bit_util::kPrecedingBitmask[8 - prologue] ^
+                   bit_util::kPrecedingBitmask[8 - prologue + length];
     data[offset / 8] = value ? data[offset / 8] | mask : data[offset / 8] & ~mask;
     return;
   }
 
   // align to a byte boundary
-  data[offset / 8] = BitUtil::SpliceWord(8 - prologue, data[offset / 8], set_byte);
+  data[offset / 8] = bit_util::SpliceWord(8 - prologue, data[offset / 8], set_byte);
   offset += prologue;
   length -= prologue;
 
   // set values per byte
   DCHECK_EQ(offset % 8, 0);
   std::memset(data + offset / 8, set_byte, length / 8);
-  offset += BitUtil::RoundDown(length, 8);
-  length -= BitUtil::RoundDown(length, 8);
+  offset += bit_util::RoundDown(length, 8);
+  length -= bit_util::RoundDown(length, 8);
 
   // clean up
   DCHECK_LT(length, 8);
   if (length > 0) {
     data[offset / 8] =
-        BitUtil::SpliceWord(static_cast<int32_t>(length), set_byte, data[offset / 8]);
+        bit_util::SpliceWord(static_cast<int32_t>(length), set_byte, data[offset / 8]);
   }
 }
 
@@ -125,5 +125,5 @@ void ClearBitmap(uint8_t* data, int64_t offset, int64_t length) {
   SetBitmapImpl<false>(data, offset, length);
 }
 
-}  // namespace BitUtil
+}  // namespace bit_util
 }  // namespace arrow
diff --git a/cpp/src/arrow/util/bit_util.h b/cpp/src/arrow/util/bit_util.h
index b6b5f2dfc1d..8583e10b226 100644
--- a/cpp/src/arrow/util/bit_util.h
+++ b/cpp/src/arrow/util/bit_util.h
@@ -48,7 +48,7 @@ typename std::make_unsigned<Integer>::type as_unsigned(Integer x) {
 
 }  // namespace detail
 
-namespace BitUtil {
+namespace bit_util {
 
 // The number of set bits in a given unsigned byte value, pre-computed
 //
@@ -162,7 +162,7 @@ constexpr int64_t RoundUpToMultipleOf64(int64_t num) {
 //
 // The covering bytes is the length (in bytes) of this new aligned slice.
 constexpr int64_t CoveringBytes(int64_t offset, int64_t length) {
-  return (BitUtil::RoundUp(length + offset, 8) - BitUtil::RoundDown(offset, 8)) / 8;
+  return (bit_util::RoundUp(length + offset, 8) - bit_util::RoundDown(offset, 8)) / 8;
 }
 
 // Returns the 'num_bits' least-significant bits of 'v'.
@@ -353,5 +353,5 @@ constexpr Word SpliceWord(int n, Word low, Word high) {
   return (high & ~PrecedingWordBitmask<Word>(n)) | (low & PrecedingWordBitmask<Word>(n));
 }
 
-}  // namespace BitUtil
+}  // namespace bit_util
 }  // namespace arrow
diff --git a/cpp/src/arrow/util/bit_util_benchmark.cc b/cpp/src/arrow/util/bit_util_benchmark.cc
index 8a4f3e0c558..258fd27785e 100644
--- a/cpp/src/arrow/util/bit_util_benchmark.cc
+++ b/cpp/src/arrow/util/bit_util_benchmark.cc
@@ -43,7 +43,7 @@
 #include "arrow/util/bitmap_writer.h"
 
 namespace arrow {
-namespace BitUtil {
+namespace bit_util {
 
 constexpr int64_t kBufferSize = 1024 * 8;
 
@@ -57,7 +57,7 @@ class NaiveBitmapReader {
   NaiveBitmapReader(const uint8_t* bitmap, int64_t start_offset, int64_t length)
       : bitmap_(bitmap), position_(0) {}
 
-  bool IsSet() const { return BitUtil::GetBit(bitmap_, position_); }
+  bool IsSet() const { return bit_util::GetBit(bitmap_, position_); }
 
   bool IsNotSet() const { return !IsSet(); }
 
@@ -440,7 +440,7 @@ static void SetBitsTo(benchmark::State& state) {
   std::shared_ptr<Buffer> buffer = CreateRandomBuffer(nbytes);
 
   for (auto _ : state) {
-    BitUtil::SetBitsTo(buffer->mutable_data(), /*offset=*/0, nbytes * 8, true);
+    bit_util::SetBitsTo(buffer->mutable_data(), /*offset=*/0, nbytes * 8, true);
   }
   state.SetBytesProcessed(state.iterations() * nbytes);
 }
@@ -556,5 +556,5 @@ BENCHMARK(BenchmarkBitmapVisitBitsetAnd)->Ranges(AND_BENCHMARK_RANGES);
 BENCHMARK(BenchmarkBitmapVisitUInt8And)->Ranges(AND_BENCHMARK_RANGES);
 BENCHMARK(BenchmarkBitmapVisitUInt64And)->Ranges(AND_BENCHMARK_RANGES);
 
-}  // namespace BitUtil
+}  // namespace bit_util
 }  // namespace arrow
diff --git a/cpp/src/arrow/util/bit_util_test.cc b/cpp/src/arrow/util/bit_util_test.cc
index 4a12384a416..9fa7b882b71 100644
--- a/cpp/src/arrow/util/bit_util_test.cc
+++ b/cpp/src/arrow/util/bit_util_test.cc
@@ -155,7 +155,7 @@ void ASSERT_BYTES_EQ(const uint8_t* left, const std::vector<uint8_t>& right) {
 }
 
 TEST(BitUtilTests, TestIsMultipleOf64) {
-  using BitUtil::IsMultipleOf64;
+  using bit_util::IsMultipleOf64;
   EXPECT_TRUE(IsMultipleOf64(64));
   EXPECT_TRUE(IsMultipleOf64(0));
   EXPECT_TRUE(IsMultipleOf64(128));
@@ -165,7 +165,7 @@ TEST(BitUtilTests, TestIsMultipleOf64) {
 }
 
 TEST(BitUtilTests, TestNextPower2) {
-  using BitUtil::NextPower2;
+  using bit_util::NextPower2;
 
   ASSERT_EQ(8, NextPower2(6));
   ASSERT_EQ(8, NextPower2(8));
@@ -185,7 +185,7 @@ TEST(BitUtilTests, TestNextPower2) {
 }
 
 TEST(BitUtilTests, BytesForBits) {
-  using BitUtil::BytesForBits;
+  using bit_util::BytesForBits;
 
   ASSERT_EQ(BytesForBits(0), 0);
   ASSERT_EQ(BytesForBits(1), 1);
@@ -258,7 +258,7 @@ class TestBitmapUInt64Reader : public ::testing::Test {
       const auto nbits = std::min<int64_t>(64, length - i);
       uint64_t word = reader.NextWord();
       for (int64_t j = 0; j < nbits; ++j) {
-        ASSERT_EQ(word & 1, BitUtil::GetBit(buffer.data(), start_offset + i + j));
+        ASSERT_EQ(word & 1, bit_util::GetBit(buffer.data(), start_offset + i + j));
         word >>= 1;
       }
     }
@@ -492,7 +492,7 @@ TEST_F(TestSetBitRunReader, AllZeros) {
 TEST_F(TestSetBitRunReader, AllOnes) {
   const int64_t kBufferSize = 256;
   ASSERT_OK_AND_ASSIGN(auto buffer, AllocateEmptyBitmap(kBufferSize));
-  BitUtil::SetBitsTo(buffer->mutable_data(), 0, kBufferSize, true);
+  bit_util::SetBitsTo(buffer->mutable_data(), 0, kBufferSize, true);
 
   for (const auto range : BufferTestRanges(*buffer)) {
     if (range.length > 0) {
@@ -509,9 +509,9 @@ TEST_F(TestSetBitRunReader, Small) {
   const int64_t kOnesLength = 64;
   const int64_t kSecondOnesStart = kBufferSize - kOnesLength;
   ASSERT_OK_AND_ASSIGN(auto buffer, AllocateEmptyBitmap(kBufferSize));
-  BitUtil::SetBitsTo(buffer->mutable_data(), 0, kBufferSize, false);
-  BitUtil::SetBitsTo(buffer->mutable_data(), 0, kOnesLength, true);
-  BitUtil::SetBitsTo(buffer->mutable_data(), kSecondOnesStart, kOnesLength, true);
+  bit_util::SetBitsTo(buffer->mutable_data(), 0, kBufferSize, false);
+  bit_util::SetBitsTo(buffer->mutable_data(), 0, kOnesLength, true);
+  bit_util::SetBitsTo(buffer->mutable_data(), kSecondOnesStart, kOnesLength, true);
 
   for (const auto range : BufferTestRanges(*buffer)) {
     std::vector<internal::SetBitRun> expected;
@@ -532,9 +532,9 @@ TEST_F(TestSetBitRunReader, SingleRun) {
   ASSERT_OK_AND_ASSIGN(auto buffer, AllocateEmptyBitmap(kBufferSize));
 
   for (const auto ones_range : BufferTestRanges(*buffer)) {
-    BitUtil::SetBitsTo(buffer->mutable_data(), 0, kBufferSize, false);
-    BitUtil::SetBitsTo(buffer->mutable_data(), ones_range.offset, ones_range.length,
-                       true);
+    bit_util::SetBitsTo(buffer->mutable_data(), 0, kBufferSize, false);
+    bit_util::SetBitsTo(buffer->mutable_data(), ones_range.offset, ones_range.length,
+                        true);
     for (const auto range : BufferTestRanges(*buffer)) {
       std::vector<internal::SetBitRun> expected;
 
@@ -610,7 +610,7 @@ TEST(BitRunReader, NormalOperation) {
 TEST(BitRunReader, AllFirstByteCombos) {
   for (int offset = 0; offset < 8; offset++) {
     for (int64_t x = 0; x < (1 << 8) - 1; x++) {
-      int64_t bits = BitUtil::ToLittleEndian(x);
+      int64_t bits = bit_util::ToLittleEndian(x);
       internal::BitRunReader reader(reinterpret_cast<uint8_t*>(&bits),
                                     /*start_offset=*/offset,
                                     /*length=*/8 - offset);
@@ -1136,7 +1136,7 @@ TYPED_TEST(TestGenerateBits, NormalOperation) {
           }
         }
         // Check the byte following generated contents wasn't clobbered
-        auto byte_after = bitmap[BitUtil::CeilDiv(start_offset + length, 8)];
+        auto byte_after = bitmap[bit_util::CeilDiv(start_offset + length, 8)];
         ASSERT_EQ(byte_after, fill_byte);
       }
     }
@@ -1469,7 +1469,7 @@ static inline int64_t SlowCountBits(const uint8_t* data, int64_t bit_offset,
                                     int64_t length) {
   int64_t count = 0;
   for (int64_t i = bit_offset; i < bit_offset + length; ++i) {
-    if (BitUtil::GetBit(data, i)) {
+    if (bit_util::GetBit(data, i)) {
       ++count;
     }
   }
@@ -1499,7 +1499,7 @@ TEST(BitUtilTests, TestCountSetBits) {
 }
 
 TEST(BitUtilTests, TestSetBitsTo) {
-  using BitUtil::SetBitsTo;
+  using bit_util::SetBitsTo;
   for (const auto fill_byte_int : {0x00, 0xff}) {
     const uint8_t fill_byte = static_cast<uint8_t>(fill_byte_int);
     {
@@ -1536,43 +1536,43 @@ TEST(BitUtilTests, TestSetBitsTo) {
 }
 
 TEST(BitUtilTests, TestSetBitmap) {
-  using BitUtil::SetBitsTo;
+  using bit_util::SetBitsTo;
   for (const auto fill_byte_int : {0xff}) {
     const uint8_t fill_byte = static_cast<uint8_t>(fill_byte_int);
     {
       // test set within a byte
       uint8_t bitmap[] = {fill_byte, fill_byte, fill_byte, fill_byte};
-      BitUtil::SetBitmap(bitmap, 2, 2);
-      BitUtil::ClearBitmap(bitmap, 4, 2);
+      bit_util::SetBitmap(bitmap, 2, 2);
+      bit_util::ClearBitmap(bitmap, 4, 2);
       ASSERT_BYTES_EQ(bitmap, {static_cast<uint8_t>((fill_byte & ~0x3C) | 0xC)});
     }
     {
       // test straddling a single byte boundary
       uint8_t bitmap[] = {fill_byte, fill_byte, fill_byte, fill_byte};
-      BitUtil::SetBitmap(bitmap, 4, 7);
-      BitUtil::ClearBitmap(bitmap, 11, 7);
+      bit_util::SetBitmap(bitmap, 4, 7);
+      bit_util::ClearBitmap(bitmap, 11, 7);
       ASSERT_BYTES_EQ(bitmap, {static_cast<uint8_t>((fill_byte & 0xF) | 0xF0), 0x7,
                                static_cast<uint8_t>(fill_byte & ~0x3)});
     }
     {
       // test byte aligned end
       uint8_t bitmap[] = {fill_byte, fill_byte, fill_byte, fill_byte};
-      BitUtil::SetBitmap(bitmap, 4, 4);
-      BitUtil::ClearBitmap(bitmap, 8, 8);
+      bit_util::SetBitmap(bitmap, 4, 4);
+      bit_util::ClearBitmap(bitmap, 8, 8);
       ASSERT_BYTES_EQ(bitmap,
                       {static_cast<uint8_t>((fill_byte & 0xF) | 0xF0), 0x00, fill_byte});
     }
     {
       // test byte aligned end, multiple bytes
       uint8_t bitmap[] = {fill_byte, fill_byte, fill_byte, fill_byte};
-      BitUtil::ClearBitmap(bitmap, 0, 24);
+      bit_util::ClearBitmap(bitmap, 0, 24);
       uint8_t false_byte = static_cast<uint8_t>(0);
       ASSERT_BYTES_EQ(bitmap, {false_byte, false_byte, false_byte, fill_byte});
     }
     {
       // ASAN test against out of bound access (ARROW-13803)
       uint8_t bitmap[1] = {fill_byte};
-      BitUtil::ClearBitmap(bitmap, 0, 8);
+      bit_util::ClearBitmap(bitmap, 0, 8);
       ASSERT_EQ(bitmap[0], 0);
     }
   }
@@ -1598,7 +1598,7 @@ TEST(BitUtilTests, TestCopyBitmap) {
                            CopyBitmap(default_memory_pool(), src, offset, copy_length));
 
       for (int64_t i = 0; i < copy_length; ++i) {
-        ASSERT_EQ(BitUtil::GetBit(src, i + offset), BitUtil::GetBit(copy->data(), i));
+        ASSERT_EQ(bit_util::GetBit(src, i + offset), bit_util::GetBit(copy->data(), i));
       }
     }
   }
@@ -1630,14 +1630,14 @@ TEST(BitUtilTests, TestCopyBitmapPreAllocated) {
         CopyBitmap(src, offset, copy_length, copy->mutable_data(), dest_offset);
 
         for (int64_t i = 0; i < dest_offset; ++i) {
-          ASSERT_EQ(BitUtil::GetBit(other, i), BitUtil::GetBit(copy->data(), i));
+          ASSERT_EQ(bit_util::GetBit(other, i), bit_util::GetBit(copy->data(), i));
         }
         for (int64_t i = 0; i < copy_length; ++i) {
-          ASSERT_EQ(BitUtil::GetBit(src, i + offset),
-                    BitUtil::GetBit(copy->data(), i + dest_offset));
+          ASSERT_EQ(bit_util::GetBit(src, i + offset),
+                    bit_util::GetBit(copy->data(), i + dest_offset));
         }
         for (int64_t i = dest_offset + copy_length; i < (other_buffer->size() * 8); ++i) {
-          ASSERT_EQ(BitUtil::GetBit(other, i), BitUtil::GetBit(copy->data(), i));
+          ASSERT_EQ(bit_util::GetBit(other, i), bit_util::GetBit(copy->data(), i));
         }
       }
     }
@@ -1670,14 +1670,14 @@ TEST(BitUtilTests, TestCopyAndInvertBitmapPreAllocated) {
         InvertBitmap(src, offset, copy_length, copy->mutable_data(), dest_offset);
 
         for (int64_t i = 0; i < dest_offset; ++i) {
-          ASSERT_EQ(BitUtil::GetBit(other, i), BitUtil::GetBit(copy->data(), i));
+          ASSERT_EQ(bit_util::GetBit(other, i), bit_util::GetBit(copy->data(), i));
         }
         for (int64_t i = 0; i < copy_length; ++i) {
-          ASSERT_EQ(BitUtil::GetBit(src, i + offset),
-                    !BitUtil::GetBit(copy->data(), i + dest_offset));
+          ASSERT_EQ(bit_util::GetBit(src, i + offset),
+                    !bit_util::GetBit(copy->data(), i + dest_offset));
         }
         for (int64_t i = dest_offset + copy_length; i < (other_buffer->size() * 8); ++i) {
-          ASSERT_EQ(BitUtil::GetBit(other, i), BitUtil::GetBit(copy->data(), i));
+          ASSERT_EQ(bit_util::GetBit(other, i), bit_util::GetBit(copy->data(), i));
         }
       }
     }
@@ -1695,7 +1695,7 @@ TEST(BitUtilTests, TestBitmapEquals) {
   std::vector<int64_t> lengths = {srcBufferSize * 8 - 4, srcBufferSize * 8};
   std::vector<int64_t> offsets = {0, 12, 16, 32, 37, 63, 64, 128};
 
-  const auto dstBufferSize = srcBufferSize + BitUtil::BytesForBits(*std::max_element(
+  const auto dstBufferSize = srcBufferSize + bit_util::BytesForBits(*std::max_element(
                                                  offsets.cbegin(), offsets.cend()));
   ASSERT_OK_AND_ASSIGN(auto dst_buffer, AllocateBuffer(dstBufferSize))
   uint8_t* dst = dst_buffer->mutable_data();
@@ -1728,158 +1728,158 @@ TEST(BitUtilTests, TestBitmapEquals) {
 }
 
 TEST(BitUtil, CeilDiv) {
-  EXPECT_EQ(BitUtil::CeilDiv(0, 1), 0);
-  EXPECT_EQ(BitUtil::CeilDiv(1, 1), 1);
-  EXPECT_EQ(BitUtil::CeilDiv(1, 2), 1);
-  EXPECT_EQ(BitUtil::CeilDiv(0, 8), 0);
-  EXPECT_EQ(BitUtil::CeilDiv(1, 8), 1);
-  EXPECT_EQ(BitUtil::CeilDiv(7, 8), 1);
-  EXPECT_EQ(BitUtil::CeilDiv(8, 8), 1);
-  EXPECT_EQ(BitUtil::CeilDiv(9, 8), 2);
-  EXPECT_EQ(BitUtil::CeilDiv(9, 9), 1);
-  EXPECT_EQ(BitUtil::CeilDiv(10000000000, 10), 1000000000);
-  EXPECT_EQ(BitUtil::CeilDiv(10, 10000000000), 1);
-  EXPECT_EQ(BitUtil::CeilDiv(100000000000, 10000000000), 10);
+  EXPECT_EQ(bit_util::CeilDiv(0, 1), 0);
+  EXPECT_EQ(bit_util::CeilDiv(1, 1), 1);
+  EXPECT_EQ(bit_util::CeilDiv(1, 2), 1);
+  EXPECT_EQ(bit_util::CeilDiv(0, 8), 0);
+  EXPECT_EQ(bit_util::CeilDiv(1, 8), 1);
+  EXPECT_EQ(bit_util::CeilDiv(7, 8), 1);
+  EXPECT_EQ(bit_util::CeilDiv(8, 8), 1);
+  EXPECT_EQ(bit_util::CeilDiv(9, 8), 2);
+  EXPECT_EQ(bit_util::CeilDiv(9, 9), 1);
+  EXPECT_EQ(bit_util::CeilDiv(10000000000, 10), 1000000000);
+  EXPECT_EQ(bit_util::CeilDiv(10, 10000000000), 1);
+  EXPECT_EQ(bit_util::CeilDiv(100000000000, 10000000000), 10);
 
   // test overflow
   int64_t value = std::numeric_limits<int64_t>::max() - 1;
   int64_t divisor = std::numeric_limits<int64_t>::max();
-  EXPECT_EQ(BitUtil::CeilDiv(value, divisor), 1);
+  EXPECT_EQ(bit_util::CeilDiv(value, divisor), 1);
 
   value = std::numeric_limits<int64_t>::max();
-  EXPECT_EQ(BitUtil::CeilDiv(value, divisor), 1);
+  EXPECT_EQ(bit_util::CeilDiv(value, divisor), 1);
 }
 
 TEST(BitUtil, RoundUp) {
-  EXPECT_EQ(BitUtil::RoundUp(0, 1), 0);
-  EXPECT_EQ(BitUtil::RoundUp(1, 1), 1);
-  EXPECT_EQ(BitUtil::RoundUp(1, 2), 2);
-  EXPECT_EQ(BitUtil::RoundUp(6, 2), 6);
-  EXPECT_EQ(BitUtil::RoundUp(0, 3), 0);
-  EXPECT_EQ(BitUtil::RoundUp(7, 3), 9);
-  EXPECT_EQ(BitUtil::RoundUp(9, 9), 9);
-  EXPECT_EQ(BitUtil::RoundUp(10000000001, 10), 10000000010);
-  EXPECT_EQ(BitUtil::RoundUp(10, 10000000000), 10000000000);
-  EXPECT_EQ(BitUtil::RoundUp(100000000000, 10000000000), 100000000000);
+  EXPECT_EQ(bit_util::RoundUp(0, 1), 0);
+  EXPECT_EQ(bit_util::RoundUp(1, 1), 1);
+  EXPECT_EQ(bit_util::RoundUp(1, 2), 2);
+  EXPECT_EQ(bit_util::RoundUp(6, 2), 6);
+  EXPECT_EQ(bit_util::RoundUp(0, 3), 0);
+  EXPECT_EQ(bit_util::RoundUp(7, 3), 9);
+  EXPECT_EQ(bit_util::RoundUp(9, 9), 9);
+  EXPECT_EQ(bit_util::RoundUp(10000000001, 10), 10000000010);
+  EXPECT_EQ(bit_util::RoundUp(10, 10000000000), 10000000000);
+  EXPECT_EQ(bit_util::RoundUp(100000000000, 10000000000), 100000000000);
 
   // test overflow
   int64_t value = std::numeric_limits<int64_t>::max() - 1;
   int64_t divisor = std::numeric_limits<int64_t>::max();
-  EXPECT_EQ(BitUtil::RoundUp(value, divisor), divisor);
+  EXPECT_EQ(bit_util::RoundUp(value, divisor), divisor);
 
   value = std::numeric_limits<int64_t>::max();
-  EXPECT_EQ(BitUtil::RoundUp(value, divisor), divisor);
+  EXPECT_EQ(bit_util::RoundUp(value, divisor), divisor);
 }
 
 TEST(BitUtil, RoundDown) {
-  EXPECT_EQ(BitUtil::RoundDown(0, 1), 0);
-  EXPECT_EQ(BitUtil::RoundDown(1, 1), 1);
-  EXPECT_EQ(BitUtil::RoundDown(1, 2), 0);
-  EXPECT_EQ(BitUtil::RoundDown(6, 2), 6);
-  EXPECT_EQ(BitUtil::RoundDown(5, 7), 0);
-  EXPECT_EQ(BitUtil::RoundDown(10, 7), 7);
-  EXPECT_EQ(BitUtil::RoundDown(7, 3), 6);
-  EXPECT_EQ(BitUtil::RoundDown(9, 9), 9);
-  EXPECT_EQ(BitUtil::RoundDown(10000000001, 10), 10000000000);
-  EXPECT_EQ(BitUtil::RoundDown(10, 10000000000), 0);
-  EXPECT_EQ(BitUtil::RoundDown(100000000000, 10000000000), 100000000000);
+  EXPECT_EQ(bit_util::RoundDown(0, 1), 0);
+  EXPECT_EQ(bit_util::RoundDown(1, 1), 1);
+  EXPECT_EQ(bit_util::RoundDown(1, 2), 0);
+  EXPECT_EQ(bit_util::RoundDown(6, 2), 6);
+  EXPECT_EQ(bit_util::RoundDown(5, 7), 0);
+  EXPECT_EQ(bit_util::RoundDown(10, 7), 7);
+  EXPECT_EQ(bit_util::RoundDown(7, 3), 6);
+  EXPECT_EQ(bit_util::RoundDown(9, 9), 9);
+  EXPECT_EQ(bit_util::RoundDown(10000000001, 10), 10000000000);
+  EXPECT_EQ(bit_util::RoundDown(10, 10000000000), 0);
+  EXPECT_EQ(bit_util::RoundDown(100000000000, 10000000000), 100000000000);
 
   for (int i = 0; i < 100; i++) {
     for (int j = 1; j < 100; j++) {
-      EXPECT_EQ(BitUtil::RoundDown(i, j), i - (i % j));
+      EXPECT_EQ(bit_util::RoundDown(i, j), i - (i % j));
     }
   }
 }
 
 TEST(BitUtil, CoveringBytes) {
-  EXPECT_EQ(BitUtil::CoveringBytes(0, 8), 1);
-  EXPECT_EQ(BitUtil::CoveringBytes(0, 9), 2);
-  EXPECT_EQ(BitUtil::CoveringBytes(1, 7), 1);
-  EXPECT_EQ(BitUtil::CoveringBytes(1, 8), 2);
-  EXPECT_EQ(BitUtil::CoveringBytes(2, 19), 3);
-  EXPECT_EQ(BitUtil::CoveringBytes(7, 18), 4);
+  EXPECT_EQ(bit_util::CoveringBytes(0, 8), 1);
+  EXPECT_EQ(bit_util::CoveringBytes(0, 9), 2);
+  EXPECT_EQ(bit_util::CoveringBytes(1, 7), 1);
+  EXPECT_EQ(bit_util::CoveringBytes(1, 8), 2);
+  EXPECT_EQ(bit_util::CoveringBytes(2, 19), 3);
+  EXPECT_EQ(bit_util::CoveringBytes(7, 18), 4);
 }
 
 TEST(BitUtil, TrailingBits) {
-  EXPECT_EQ(BitUtil::TrailingBits(0xFF, 0), 0);
-  EXPECT_EQ(BitUtil::TrailingBits(0xFF, 1), 1);
-  EXPECT_EQ(BitUtil::TrailingBits(0xFF, 64), 0xFF);
-  EXPECT_EQ(BitUtil::TrailingBits(0xFF, 100), 0xFF);
-  EXPECT_EQ(BitUtil::TrailingBits(0, 1), 0);
-  EXPECT_EQ(BitUtil::TrailingBits(0, 64), 0);
-  EXPECT_EQ(BitUtil::TrailingBits(1LL << 63, 0), 0);
-  EXPECT_EQ(BitUtil::TrailingBits(1LL << 63, 63), 0);
-  EXPECT_EQ(BitUtil::TrailingBits(1LL << 63, 64), 1LL << 63);
+  EXPECT_EQ(bit_util::TrailingBits(0xFF, 0), 0);
+  EXPECT_EQ(bit_util::TrailingBits(0xFF, 1), 1);
+  EXPECT_EQ(bit_util::TrailingBits(0xFF, 64), 0xFF);
+  EXPECT_EQ(bit_util::TrailingBits(0xFF, 100), 0xFF);
+  EXPECT_EQ(bit_util::TrailingBits(0, 1), 0);
+  EXPECT_EQ(bit_util::TrailingBits(0, 64), 0);
+  EXPECT_EQ(bit_util::TrailingBits(1LL << 63, 0), 0);
+  EXPECT_EQ(bit_util::TrailingBits(1LL << 63, 63), 0);
+  EXPECT_EQ(bit_util::TrailingBits(1LL << 63, 64), 1LL << 63);
 }
 
 TEST(BitUtil, ByteSwap) {
-  EXPECT_EQ(BitUtil::ByteSwap(static_cast<uint32_t>(0)), 0);
-  EXPECT_EQ(BitUtil::ByteSwap(static_cast<uint32_t>(0x11223344)), 0x44332211);
+  EXPECT_EQ(bit_util::ByteSwap(static_cast<uint32_t>(0)), 0);
+  EXPECT_EQ(bit_util::ByteSwap(static_cast<uint32_t>(0x11223344)), 0x44332211);
 
-  EXPECT_EQ(BitUtil::ByteSwap(static_cast<int32_t>(0)), 0);
-  EXPECT_EQ(BitUtil::ByteSwap(static_cast<int32_t>(0x11223344)), 0x44332211);
+  EXPECT_EQ(bit_util::ByteSwap(static_cast<int32_t>(0)), 0);
+  EXPECT_EQ(bit_util::ByteSwap(static_cast<int32_t>(0x11223344)), 0x44332211);
 
-  EXPECT_EQ(BitUtil::ByteSwap(static_cast<uint64_t>(0)), 0);
-  EXPECT_EQ(BitUtil::ByteSwap(static_cast<uint64_t>(0x1122334455667788)),
+  EXPECT_EQ(bit_util::ByteSwap(static_cast<uint64_t>(0)), 0);
+  EXPECT_EQ(bit_util::ByteSwap(static_cast<uint64_t>(0x1122334455667788)),
             0x8877665544332211);
 
-  EXPECT_EQ(BitUtil::ByteSwap(static_cast<int64_t>(0)), 0);
-  EXPECT_EQ(BitUtil::ByteSwap(static_cast<int64_t>(0x1122334455667788)),
+  EXPECT_EQ(bit_util::ByteSwap(static_cast<int64_t>(0)), 0);
+  EXPECT_EQ(bit_util::ByteSwap(static_cast<int64_t>(0x1122334455667788)),
             0x8877665544332211);
 
-  EXPECT_EQ(BitUtil::ByteSwap(static_cast<int16_t>(0)), 0);
-  EXPECT_EQ(BitUtil::ByteSwap(static_cast<int16_t>(0x1122)), 0x2211);
+  EXPECT_EQ(bit_util::ByteSwap(static_cast<int16_t>(0)), 0);
+  EXPECT_EQ(bit_util::ByteSwap(static_cast<int16_t>(0x1122)), 0x2211);
 
-  EXPECT_EQ(BitUtil::ByteSwap(static_cast<uint16_t>(0)), 0);
-  EXPECT_EQ(BitUtil::ByteSwap(static_cast<uint16_t>(0x1122)), 0x2211);
+  EXPECT_EQ(bit_util::ByteSwap(static_cast<uint16_t>(0)), 0);
+  EXPECT_EQ(bit_util::ByteSwap(static_cast<uint16_t>(0x1122)), 0x2211);
 
-  EXPECT_EQ(BitUtil::ByteSwap(static_cast<int8_t>(0)), 0);
-  EXPECT_EQ(BitUtil::ByteSwap(static_cast<int8_t>(0x11)), 0x11);
+  EXPECT_EQ(bit_util::ByteSwap(static_cast<int8_t>(0)), 0);
+  EXPECT_EQ(bit_util::ByteSwap(static_cast<int8_t>(0x11)), 0x11);
 
-  EXPECT_EQ(BitUtil::ByteSwap(static_cast<uint8_t>(0)), 0);
-  EXPECT_EQ(BitUtil::ByteSwap(static_cast<uint8_t>(0x11)), 0x11);
+  EXPECT_EQ(bit_util::ByteSwap(static_cast<uint8_t>(0)), 0);
+  EXPECT_EQ(bit_util::ByteSwap(static_cast<uint8_t>(0x11)), 0x11);
 
-  EXPECT_EQ(BitUtil::ByteSwap(static_cast<float>(0)), 0);
+  EXPECT_EQ(bit_util::ByteSwap(static_cast<float>(0)), 0);
   uint32_t srci32 = 0xaabbccdd, expectedi32 = 0xddccbbaa;
   float srcf32 = SafeCopy<float>(srci32);
   float expectedf32 = SafeCopy<float>(expectedi32);
-  EXPECT_EQ(BitUtil::ByteSwap(srcf32), expectedf32);
+  EXPECT_EQ(bit_util::ByteSwap(srcf32), expectedf32);
   uint64_t srci64 = 0xaabb11223344ccdd, expectedi64 = 0xddcc44332211bbaa;
   double srcd64 = SafeCopy<double>(srci64);
   double expectedd64 = SafeCopy<double>(expectedi64);
-  EXPECT_EQ(BitUtil::ByteSwap(srcd64), expectedd64);
+  EXPECT_EQ(bit_util::ByteSwap(srcd64), expectedd64);
 }
 
 TEST(BitUtil, Log2) {
-  EXPECT_EQ(BitUtil::Log2(1), 0);
-  EXPECT_EQ(BitUtil::Log2(2), 1);
-  EXPECT_EQ(BitUtil::Log2(3), 2);
-  EXPECT_EQ(BitUtil::Log2(4), 2);
-  EXPECT_EQ(BitUtil::Log2(5), 3);
-  EXPECT_EQ(BitUtil::Log2(8), 3);
-  EXPECT_EQ(BitUtil::Log2(9), 4);
-  EXPECT_EQ(BitUtil::Log2(INT_MAX), 31);
-  EXPECT_EQ(BitUtil::Log2(UINT_MAX), 32);
-  EXPECT_EQ(BitUtil::Log2(ULLONG_MAX), 64);
+  EXPECT_EQ(bit_util::Log2(1), 0);
+  EXPECT_EQ(bit_util::Log2(2), 1);
+  EXPECT_EQ(bit_util::Log2(3), 2);
+  EXPECT_EQ(bit_util::Log2(4), 2);
+  EXPECT_EQ(bit_util::Log2(5), 3);
+  EXPECT_EQ(bit_util::Log2(8), 3);
+  EXPECT_EQ(bit_util::Log2(9), 4);
+  EXPECT_EQ(bit_util::Log2(INT_MAX), 31);
+  EXPECT_EQ(bit_util::Log2(UINT_MAX), 32);
+  EXPECT_EQ(bit_util::Log2(ULLONG_MAX), 64);
 }
 
 TEST(BitUtil, NumRequiredBits) {
-  EXPECT_EQ(BitUtil::NumRequiredBits(0), 0);
-  EXPECT_EQ(BitUtil::NumRequiredBits(1), 1);
-  EXPECT_EQ(BitUtil::NumRequiredBits(2), 2);
-  EXPECT_EQ(BitUtil::NumRequiredBits(3), 2);
-  EXPECT_EQ(BitUtil::NumRequiredBits(4), 3);
-  EXPECT_EQ(BitUtil::NumRequiredBits(5), 3);
-  EXPECT_EQ(BitUtil::NumRequiredBits(7), 3);
-  EXPECT_EQ(BitUtil::NumRequiredBits(8), 4);
-  EXPECT_EQ(BitUtil::NumRequiredBits(9), 4);
-  EXPECT_EQ(BitUtil::NumRequiredBits(UINT_MAX - 1), 32);
-  EXPECT_EQ(BitUtil::NumRequiredBits(UINT_MAX), 32);
-  EXPECT_EQ(BitUtil::NumRequiredBits(static_cast<uint64_t>(UINT_MAX) + 1), 33);
-  EXPECT_EQ(BitUtil::NumRequiredBits(ULLONG_MAX / 2), 63);
-  EXPECT_EQ(BitUtil::NumRequiredBits(ULLONG_MAX / 2 + 1), 64);
-  EXPECT_EQ(BitUtil::NumRequiredBits(ULLONG_MAX - 1), 64);
-  EXPECT_EQ(BitUtil::NumRequiredBits(ULLONG_MAX), 64);
+  EXPECT_EQ(bit_util::NumRequiredBits(0), 0);
+  EXPECT_EQ(bit_util::NumRequiredBits(1), 1);
+  EXPECT_EQ(bit_util::NumRequiredBits(2), 2);
+  EXPECT_EQ(bit_util::NumRequiredBits(3), 2);
+  EXPECT_EQ(bit_util::NumRequiredBits(4), 3);
+  EXPECT_EQ(bit_util::NumRequiredBits(5), 3);
+  EXPECT_EQ(bit_util::NumRequiredBits(7), 3);
+  EXPECT_EQ(bit_util::NumRequiredBits(8), 4);
+  EXPECT_EQ(bit_util::NumRequiredBits(9), 4);
+  EXPECT_EQ(bit_util::NumRequiredBits(UINT_MAX - 1), 32);
+  EXPECT_EQ(bit_util::NumRequiredBits(UINT_MAX), 32);
+  EXPECT_EQ(bit_util::NumRequiredBits(static_cast<uint64_t>(UINT_MAX) + 1), 33);
+  EXPECT_EQ(bit_util::NumRequiredBits(ULLONG_MAX / 2), 63);
+  EXPECT_EQ(bit_util::NumRequiredBits(ULLONG_MAX / 2 + 1), 64);
+  EXPECT_EQ(bit_util::NumRequiredBits(ULLONG_MAX - 1), 64);
+  EXPECT_EQ(bit_util::NumRequiredBits(ULLONG_MAX), 64);
 }
 
 #define U32(x) static_cast<uint32_t>(x)
@@ -1887,63 +1887,63 @@ TEST(BitUtil, NumRequiredBits) {
 #define S64(x) static_cast<int64_t>(x)
 
 TEST(BitUtil, CountLeadingZeros) {
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U32(0)), 32);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U32(1)), 31);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U32(2)), 30);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U32(3)), 30);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U32(4)), 29);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U32(7)), 29);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U32(8)), 28);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U32(UINT_MAX / 2)), 1);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U32(UINT_MAX / 2 + 1)), 0);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U32(UINT_MAX)), 0);
-
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U64(0)), 64);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U64(1)), 63);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U64(2)), 62);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U64(3)), 62);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U64(4)), 61);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U64(7)), 61);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U64(8)), 60);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U64(UINT_MAX)), 32);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U64(UINT_MAX) + 1), 31);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U64(ULLONG_MAX / 2)), 1);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U64(ULLONG_MAX / 2 + 1)), 0);
-  EXPECT_EQ(BitUtil::CountLeadingZeros(U64(ULLONG_MAX)), 0);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U32(0)), 32);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U32(1)), 31);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U32(2)), 30);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U32(3)), 30);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U32(4)), 29);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U32(7)), 29);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U32(8)), 28);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U32(UINT_MAX / 2)), 1);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U32(UINT_MAX / 2 + 1)), 0);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U32(UINT_MAX)), 0);
+
+  EXPECT_EQ(bit_util::CountLeadingZeros(U64(0)), 64);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U64(1)), 63);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U64(2)), 62);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U64(3)), 62);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U64(4)), 61);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U64(7)), 61);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U64(8)), 60);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U64(UINT_MAX)), 32);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U64(UINT_MAX) + 1), 31);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U64(ULLONG_MAX / 2)), 1);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U64(ULLONG_MAX / 2 + 1)), 0);
+  EXPECT_EQ(bit_util::CountLeadingZeros(U64(ULLONG_MAX)), 0);
 }
 
 TEST(BitUtil, CountTrailingZeros) {
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U32(0)), 32);
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U32(1) << 31), 31);
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U32(1) << 30), 30);
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U32(1) << 29), 29);
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U32(1) << 28), 28);
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U32(8)), 3);
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U32(4)), 2);
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U32(2)), 1);
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U32(1)), 0);
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U32(ULONG_MAX)), 0);
-
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U64(0)), 64);
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U64(1) << 63), 63);
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U64(1) << 62), 62);
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U64(1) << 61), 61);
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U64(1) << 60), 60);
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U64(8)), 3);
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U64(4)), 2);
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U64(2)), 1);
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U64(1)), 0);
-  EXPECT_EQ(BitUtil::CountTrailingZeros(U64(ULLONG_MAX)), 0);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U32(0)), 32);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U32(1) << 31), 31);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U32(1) << 30), 30);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U32(1) << 29), 29);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U32(1) << 28), 28);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U32(8)), 3);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U32(4)), 2);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U32(2)), 1);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U32(1)), 0);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U32(ULONG_MAX)), 0);
+
+  EXPECT_EQ(bit_util::CountTrailingZeros(U64(0)), 64);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U64(1) << 63), 63);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U64(1) << 62), 62);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U64(1) << 61), 61);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U64(1) << 60), 60);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U64(8)), 3);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U64(4)), 2);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U64(2)), 1);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U64(1)), 0);
+  EXPECT_EQ(bit_util::CountTrailingZeros(U64(ULLONG_MAX)), 0);
 }
 
 TEST(BitUtil, RoundUpToPowerOf2) {
-  EXPECT_EQ(BitUtil::RoundUpToPowerOf2(S64(7), 8), 8);
-  EXPECT_EQ(BitUtil::RoundUpToPowerOf2(S64(8), 8), 8);
-  EXPECT_EQ(BitUtil::RoundUpToPowerOf2(S64(9), 8), 16);
+  EXPECT_EQ(bit_util::RoundUpToPowerOf2(S64(7), 8), 8);
+  EXPECT_EQ(bit_util::RoundUpToPowerOf2(S64(8), 8), 8);
+  EXPECT_EQ(bit_util::RoundUpToPowerOf2(S64(9), 8), 16);
 
-  EXPECT_EQ(BitUtil::RoundUpToPowerOf2(U64(7), 8), 8);
-  EXPECT_EQ(BitUtil::RoundUpToPowerOf2(U64(8), 8), 8);
-  EXPECT_EQ(BitUtil::RoundUpToPowerOf2(U64(9), 8), 16);
+  EXPECT_EQ(bit_util::RoundUpToPowerOf2(U64(7), 8), 8);
+  EXPECT_EQ(bit_util::RoundUpToPowerOf2(U64(8), 8), 8);
+  EXPECT_EQ(bit_util::RoundUpToPowerOf2(U64(9), 8), 16);
 }
 
 #undef U32
@@ -1951,9 +1951,9 @@ TEST(BitUtil, RoundUpToPowerOf2) {
 #undef S64
 
 static void TestZigZag(int32_t v, std::array<uint8_t, 5> buffer_expect) {
-  uint8_t buffer[BitUtil::BitReader::kMaxVlqByteLength] = {};
-  BitUtil::BitWriter writer(buffer, sizeof(buffer));
-  BitUtil::BitReader reader(buffer, sizeof(buffer));
+  uint8_t buffer[bit_util::BitReader::kMaxVlqByteLength] = {};
+  bit_util::BitWriter writer(buffer, sizeof(buffer));
+  bit_util::BitReader reader(buffer, sizeof(buffer));
   writer.PutZigZagVlqInt(v);
   EXPECT_THAT(buffer, testing::ElementsAreArray(buffer_expect));
   int32_t result;
@@ -1973,9 +1973,9 @@ TEST(BitStreamUtil, ZigZag) {
 }
 
 static void TestZigZag64(int64_t v, std::array<uint8_t, 10> buffer_expect) {
-  uint8_t buffer[BitUtil::BitReader::kMaxVlqByteLengthForInt64] = {};
-  BitUtil::BitWriter writer(buffer, sizeof(buffer));
-  BitUtil::BitReader reader(buffer, sizeof(buffer));
+  uint8_t buffer[bit_util::BitReader::kMaxVlqByteLengthForInt64] = {};
+  bit_util::BitWriter writer(buffer, sizeof(buffer));
+  bit_util::BitReader reader(buffer, sizeof(buffer));
   writer.PutZigZagVlqInt(v);
   EXPECT_THAT(buffer, testing::ElementsAreArray(buffer_expect));
   int64_t result;
@@ -2006,10 +2006,10 @@ TEST(BitUtil, RoundTripLittleEndianTest) {
   uint64_t expected = std::numeric_limits<uint64_t>::max() << 56;
 #endif
 
-  uint64_t little_endian_result = BitUtil::ToLittleEndian(value);
+  uint64_t little_endian_result = bit_util::ToLittleEndian(value);
   ASSERT_EQ(expected, little_endian_result);
 
-  uint64_t from_little_endian = BitUtil::FromLittleEndian(little_endian_result);
+  uint64_t from_little_endian = bit_util::FromLittleEndian(little_endian_result);
   ASSERT_EQ(value, from_little_endian);
 }
 
@@ -2022,10 +2022,10 @@ TEST(BitUtil, RoundTripBigEndianTest) {
   uint64_t expected = value;
 #endif
 
-  uint64_t big_endian_result = BitUtil::ToBigEndian(value);
+  uint64_t big_endian_result = bit_util::ToBigEndian(value);
   ASSERT_EQ(expected, big_endian_result);
 
-  uint64_t from_big_endian = BitUtil::FromBigEndian(big_endian_result);
+  uint64_t from_big_endian = bit_util::FromBigEndian(big_endian_result);
   ASSERT_EQ(value, from_big_endian);
 }
 
@@ -2052,29 +2052,29 @@ TEST(BitUtil, BitsetStack) {
 
 TEST(SpliceWord, SpliceWord) {
   static_assert(
-      BitUtil::PrecedingWordBitmask<uint8_t>(0) == BitUtil::kPrecedingBitmask[0], "");
+      bit_util::PrecedingWordBitmask<uint8_t>(0) == bit_util::kPrecedingBitmask[0], "");
   static_assert(
-      BitUtil::PrecedingWordBitmask<uint8_t>(5) == BitUtil::kPrecedingBitmask[5], "");
-  static_assert(BitUtil::PrecedingWordBitmask<uint8_t>(8) == UINT8_MAX, "");
+      bit_util::PrecedingWordBitmask<uint8_t>(5) == bit_util::kPrecedingBitmask[5], "");
+  static_assert(bit_util::PrecedingWordBitmask<uint8_t>(8) == UINT8_MAX, "");
 
-  static_assert(BitUtil::PrecedingWordBitmask<uint64_t>(0) == uint64_t(0), "");
-  static_assert(BitUtil::PrecedingWordBitmask<uint64_t>(33) == 8589934591, "");
-  static_assert(BitUtil::PrecedingWordBitmask<uint64_t>(64) == UINT64_MAX, "");
-  static_assert(BitUtil::PrecedingWordBitmask<uint64_t>(65) == UINT64_MAX, "");
+  static_assert(bit_util::PrecedingWordBitmask<uint64_t>(0) == uint64_t(0), "");
+  static_assert(bit_util::PrecedingWordBitmask<uint64_t>(33) == 8589934591, "");
+  static_assert(bit_util::PrecedingWordBitmask<uint64_t>(64) == UINT64_MAX, "");
+  static_assert(bit_util::PrecedingWordBitmask<uint64_t>(65) == UINT64_MAX, "");
 
-  ASSERT_EQ(BitUtil::SpliceWord<uint8_t>(0, 0x12, 0xef), 0xef);
-  ASSERT_EQ(BitUtil::SpliceWord<uint8_t>(8, 0x12, 0xef), 0x12);
-  ASSERT_EQ(BitUtil::SpliceWord<uint8_t>(3, 0x12, 0xef), 0xea);
+  ASSERT_EQ(bit_util::SpliceWord<uint8_t>(0, 0x12, 0xef), 0xef);
+  ASSERT_EQ(bit_util::SpliceWord<uint8_t>(8, 0x12, 0xef), 0x12);
+  ASSERT_EQ(bit_util::SpliceWord<uint8_t>(3, 0x12, 0xef), 0xea);
 
-  ASSERT_EQ(BitUtil::SpliceWord<uint32_t>(0, 0x12345678, 0xfedcba98), 0xfedcba98);
-  ASSERT_EQ(BitUtil::SpliceWord<uint32_t>(32, 0x12345678, 0xfedcba98), 0x12345678);
-  ASSERT_EQ(BitUtil::SpliceWord<uint32_t>(24, 0x12345678, 0xfedcba98), 0xfe345678);
+  ASSERT_EQ(bit_util::SpliceWord<uint32_t>(0, 0x12345678, 0xfedcba98), 0xfedcba98);
+  ASSERT_EQ(bit_util::SpliceWord<uint32_t>(32, 0x12345678, 0xfedcba98), 0x12345678);
+  ASSERT_EQ(bit_util::SpliceWord<uint32_t>(24, 0x12345678, 0xfedcba98), 0xfe345678);
 
-  ASSERT_EQ(BitUtil::SpliceWord<uint64_t>(0, 0x0123456789abcdef, 0xfedcba9876543210),
+  ASSERT_EQ(bit_util::SpliceWord<uint64_t>(0, 0x0123456789abcdef, 0xfedcba9876543210),
             0xfedcba9876543210);
-  ASSERT_EQ(BitUtil::SpliceWord<uint64_t>(64, 0x0123456789abcdef, 0xfedcba9876543210),
+  ASSERT_EQ(bit_util::SpliceWord<uint64_t>(64, 0x0123456789abcdef, 0xfedcba9876543210),
             0x0123456789abcdef);
-  ASSERT_EQ(BitUtil::SpliceWord<uint64_t>(48, 0x0123456789abcdef, 0xfedcba9876543210),
+  ASSERT_EQ(bit_util::SpliceWord<uint64_t>(48, 0x0123456789abcdef, 0xfedcba9876543210),
             0xfedc456789abcdef);
 }
 
@@ -2088,16 +2088,16 @@ TEST(Bitmap, ShiftingWordsOptimization) {
 
     for (int seed = 0; seed < 64; ++seed) {
       random_bytes(sizeof(word), seed, bytes);
-      uint64_t native_word = BitUtil::FromLittleEndian(word);
+      uint64_t native_word = bit_util::FromLittleEndian(word);
 
       // bits are accessible through simple bit shifting of the word
       for (size_t i = 0; i < kBitWidth; ++i) {
-        ASSERT_EQ(BitUtil::GetBit(bytes, i), bool((native_word >> i) & 1));
+        ASSERT_EQ(bit_util::GetBit(bytes, i), bool((native_word >> i) & 1));
       }
 
       // bit offset can therefore be accommodated by shifting the word
       for (size_t offset = 0; offset < (kBitWidth * 3) / 4; ++offset) {
-        uint64_t shifted_word = arrow::BitUtil::ToLittleEndian(native_word >> offset);
+        uint64_t shifted_word = arrow::bit_util::ToLittleEndian(native_word >> offset);
         auto shifted_bytes = reinterpret_cast<uint8_t*>(&shifted_word);
         ASSERT_TRUE(
             internal::BitmapEquals(bytes, offset, shifted_bytes, 0, kBitWidth - offset));
@@ -2113,23 +2113,23 @@ TEST(Bitmap, ShiftingWordsOptimization) {
 
     for (int seed = 0; seed < 64; ++seed) {
       random_bytes(sizeof(words), seed, bytes);
-      uint64_t native_words0 = BitUtil::FromLittleEndian(words[0]);
-      uint64_t native_words1 = BitUtil::FromLittleEndian(words[1]);
+      uint64_t native_words0 = bit_util::FromLittleEndian(words[0]);
+      uint64_t native_words1 = bit_util::FromLittleEndian(words[1]);
 
       // bits are accessible through simple bit shifting of a word
       for (size_t i = 0; i < kBitWidth; ++i) {
-        ASSERT_EQ(BitUtil::GetBit(bytes, i), bool((native_words0 >> i) & 1));
+        ASSERT_EQ(bit_util::GetBit(bytes, i), bool((native_words0 >> i) & 1));
       }
       for (size_t i = 0; i < kBitWidth; ++i) {
-        ASSERT_EQ(BitUtil::GetBit(bytes, i + kBitWidth), bool((native_words1 >> i) & 1));
+        ASSERT_EQ(bit_util::GetBit(bytes, i + kBitWidth), bool((native_words1 >> i) & 1));
       }
 
       // bit offset can therefore be accommodated by shifting the word
       for (size_t offset = 1; offset < (kBitWidth * 3) / 4; offset += 3) {
         uint64_t shifted_words[2];
-        shifted_words[0] = arrow::BitUtil::ToLittleEndian(
+        shifted_words[0] = arrow::bit_util::ToLittleEndian(
             native_words0 >> offset | (native_words1 << (kBitWidth - offset)));
-        shifted_words[1] = arrow::BitUtil::ToLittleEndian(native_words1 >> offset);
+        shifted_words[1] = arrow::bit_util::ToLittleEndian(native_words1 >> offset);
         auto shifted_bytes = reinterpret_cast<uint8_t*>(shifted_words);
 
         // from offset to unshifted word boundary
diff --git a/cpp/src/arrow/util/bitmap.h b/cpp/src/arrow/util/bitmap.h
index 141f863c0b8..99e3ceb4f58 100644
--- a/cpp/src/arrow/util/bitmap.h
+++ b/cpp/src/arrow/util/bitmap.h
@@ -58,13 +58,13 @@ class ARROW_EXPORT Bitmap : public util::ToStringOstreamable<Bitmap>,
 
   Bitmap(const void* data, int64_t offset, int64_t length)
       : buffer_(std::make_shared<Buffer>(static_cast<const uint8_t*>(data),
-                                         BitUtil::BytesForBits(offset + length))),
+                                         bit_util::BytesForBits(offset + length))),
         offset_(offset),
         length_(length) {}
 
   Bitmap(void* data, int64_t offset, int64_t length)
       : buffer_(std::make_shared<MutableBuffer>(static_cast<uint8_t*>(data),
-                                                BitUtil::BytesForBits(offset + length))),
+                                                bit_util::BytesForBits(offset + length))),
         offset_(offset),
         length_(length) {}
 
@@ -82,16 +82,16 @@ class ARROW_EXPORT Bitmap : public util::ToStringOstreamable<Bitmap>,
 
   std::string Diff(const Bitmap& other) const;
 
-  bool GetBit(int64_t i) const { return BitUtil::GetBit(buffer_->data(), i + offset_); }
+  bool GetBit(int64_t i) const { return bit_util::GetBit(buffer_->data(), i + offset_); }
 
   bool operator[](int64_t i) const { return GetBit(i); }
 
   void SetBitTo(int64_t i, bool v) const {
-    BitUtil::SetBitTo(buffer_->mutable_data(), i + offset_, v);
+    bit_util::SetBitTo(buffer_->mutable_data(), i + offset_, v);
   }
 
   void SetBitsTo(bool v) {
-    BitUtil::SetBitsTo(buffer_->mutable_data(), offset_, length_, v);
+    bit_util::SetBitsTo(buffer_->mutable_data(), offset_, length_, v);
   }
 
   void CopyFrom(const Bitmap& other);
@@ -218,9 +218,9 @@ class ARROW_EXPORT Bitmap : public util::ToStringOstreamable<Bitmap>,
           if (offsets[i] == 0) {
             visited_words[i] = words[i][word_i];
           } else {
-            auto words0 = BitUtil::ToLittleEndian(words[i][word_i]);
-            auto words1 = BitUtil::ToLittleEndian(words[i][word_i + 1]);
-            visited_words[i] = BitUtil::FromLittleEndian(
+            auto words0 = bit_util::ToLittleEndian(words[i][word_i]);
+            auto words1 = bit_util::ToLittleEndian(words[i][word_i + 1]);
+            visited_words[i] = bit_util::FromLittleEndian(
                 (words0 >> offsets[i]) | (words1 << (kBitWidth - offsets[i])));
           }
         }
@@ -380,7 +380,7 @@ class ARROW_EXPORT Bitmap : public util::ToStringOstreamable<Bitmap>,
   /// string_view of all bytes which contain any bit in this Bitmap
   util::bytes_view bytes() const {
     auto byte_offset = offset_ / 8;
-    auto byte_count = BitUtil::CeilDiv(offset_ + length_, 8) - byte_offset;
+    auto byte_count = bit_util::CeilDiv(offset_ + length_, 8) - byte_offset;
     return util::bytes_view(buffer_->data() + byte_offset, byte_count);
   }
 
@@ -402,8 +402,8 @@ class ARROW_EXPORT Bitmap : public util::ToStringOstreamable<Bitmap>,
     auto bytes_addr = reinterpret_cast<intptr_t>(bytes().data());
     auto words_addr = bytes_addr - bytes_addr % sizeof(Word);
     auto word_byte_count =
-        BitUtil::RoundUpToPowerOf2(static_cast<int64_t>(bytes_addr + bytes().size()),
-                                   static_cast<int64_t>(sizeof(Word))) -
+        bit_util::RoundUpToPowerOf2(static_cast<int64_t>(bytes_addr + bytes().size()),
+                                    static_cast<int64_t>(sizeof(Word))) -
         words_addr;
     return View<Word>(reinterpret_cast<const Word*>(words_addr),
                       word_byte_count / sizeof(Word));
diff --git a/cpp/src/arrow/util/bitmap_builders.cc b/cpp/src/arrow/util/bitmap_builders.cc
index 9a91b7ac675..0348b1303b9 100644
--- a/cpp/src/arrow/util/bitmap_builders.cc
+++ b/cpp/src/arrow/util/bitmap_builders.cc
@@ -36,7 +36,7 @@ namespace {
 void FillBitsFromBytes(const std::vector<uint8_t>& bytes, uint8_t* bits) {
   for (size_t i = 0; i < bytes.size(); ++i) {
     if (bytes[i] > 0) {
-      BitUtil::SetBit(bits, i);
+      bit_util::SetBit(bits, i);
     }
   }
 }
@@ -45,7 +45,7 @@ void FillBitsFromBytes(const std::vector<uint8_t>& bytes, uint8_t* bits) {
 
 Result<std::shared_ptr<Buffer>> BytesToBits(const std::vector<uint8_t>& bytes,
                                             MemoryPool* pool) {
-  int64_t bit_length = BitUtil::BytesForBits(bytes.size());
+  int64_t bit_length = bit_util::BytesForBits(bytes.size());
 
   ARROW_ASSIGN_OR_RAISE(auto buffer, AllocateBuffer(bit_length, pool));
   uint8_t* out_buf = buffer->mutable_data();
@@ -60,11 +60,12 @@ Result<std::shared_ptr<Buffer>> BitmapAllButOne(MemoryPool* pool, int64_t length
     return Status::Invalid("invalid straggler_pos ", straggler_pos);
   }
 
-  ARROW_ASSIGN_OR_RAISE(auto buffer, AllocateBuffer(BitUtil::BytesForBits(length), pool));
+  ARROW_ASSIGN_OR_RAISE(auto buffer,
+                        AllocateBuffer(bit_util::BytesForBits(length), pool));
 
   auto bitmap_data = buffer->mutable_data();
-  BitUtil::SetBitsTo(bitmap_data, 0, length, value);
-  BitUtil::SetBitTo(bitmap_data, straggler_pos, !value);
+  bit_util::SetBitsTo(bitmap_data, 0, length, value);
+  bit_util::SetBitTo(bitmap_data, straggler_pos, !value);
   return std::move(buffer);
 }
 
diff --git a/cpp/src/arrow/util/bitmap_generate.h b/cpp/src/arrow/util/bitmap_generate.h
index 6b900f246fa..5efc5d5a1d5 100644
--- a/cpp/src/arrow/util/bitmap_generate.h
+++ b/cpp/src/arrow/util/bitmap_generate.h
@@ -39,8 +39,8 @@ void GenerateBits(uint8_t* bitmap, int64_t start_offset, int64_t length, Generat
     return;
   }
   uint8_t* cur = bitmap + start_offset / 8;
-  uint8_t bit_mask = BitUtil::kBitmask[start_offset % 8];
-  uint8_t current_byte = *cur & BitUtil::kPrecedingBitmask[start_offset % 8];
+  uint8_t bit_mask = bit_util::kBitmask[start_offset % 8];
+  uint8_t current_byte = *cur & bit_util::kPrecedingBitmask[start_offset % 8];
 
   for (int64_t index = 0; index < length; ++index) {
     const bool bit = g();
@@ -71,11 +71,11 @@ void GenerateBitsUnrolled(uint8_t* bitmap, int64_t start_offset, int64_t length,
   uint8_t current_byte;
   uint8_t* cur = bitmap + start_offset / 8;
   const uint64_t start_bit_offset = start_offset % 8;
-  uint8_t bit_mask = BitUtil::kBitmask[start_bit_offset];
+  uint8_t bit_mask = bit_util::kBitmask[start_bit_offset];
   int64_t remaining = length;
 
   if (bit_mask != 0x01) {
-    current_byte = *cur & BitUtil::kPrecedingBitmask[start_bit_offset];
+    current_byte = *cur & bit_util::kPrecedingBitmask[start_bit_offset];
     while (bit_mask != 0 && remaining > 0) {
       current_byte |= g() * bit_mask;
       bit_mask = static_cast<uint8_t>(bit_mask << 1);
diff --git a/cpp/src/arrow/util/bitmap_ops.cc b/cpp/src/arrow/util/bitmap_ops.cc
index 63c8b008f4a..33290fa4dfc 100644
--- a/cpp/src/arrow/util/bitmap_ops.cc
+++ b/cpp/src/arrow/util/bitmap_ops.cc
@@ -40,7 +40,7 @@ int64_t CountSetBits(const uint8_t* data, int64_t bit_offset, int64_t length) {
 
   const auto p = BitmapWordAlign<pop_len / 8>(data, bit_offset, length);
   for (int64_t i = bit_offset; i < bit_offset + p.leading_bits; ++i) {
-    if (BitUtil::GetBit(data, i)) {
+    if (bit_util::GetBit(data, i)) {
       ++count;
     }
   }
@@ -52,13 +52,14 @@ int64_t CountSetBits(const uint8_t* data, int64_t bit_offset, int64_t length) {
     const uint64_t* end = u64_data + p.aligned_words;
 
     constexpr int64_t kCountUnrollFactor = 4;
-    const int64_t words_rounded = BitUtil::RoundDown(p.aligned_words, kCountUnrollFactor);
+    const int64_t words_rounded =
+        bit_util::RoundDown(p.aligned_words, kCountUnrollFactor);
     int64_t count_unroll[kCountUnrollFactor] = {0};
 
     // Unroll the loop for better performance
     for (int64_t i = 0; i < words_rounded; i += kCountUnrollFactor) {
       for (int64_t k = 0; k < kCountUnrollFactor; k++) {
-        count_unroll[k] += BitUtil::PopCount(u64_data[k]);
+        count_unroll[k] += bit_util::PopCount(u64_data[k]);
       }
       u64_data += kCountUnrollFactor;
     }
@@ -68,14 +69,14 @@ int64_t CountSetBits(const uint8_t* data, int64_t bit_offset, int64_t length) {
 
     // The trailing part
     for (; u64_data < end; ++u64_data) {
-      count += BitUtil::PopCount(*u64_data);
+      count += bit_util::PopCount(*u64_data);
     }
   }
 
   // Account for left over bits (in theory we could fall back to smaller
   // versions of popcount but the code complexity is likely not worth it)
   for (int64_t i = p.trailing_bit_offset; i < bit_offset + length; ++i) {
-    if (BitUtil::GetBit(data, i)) {
+    if (bit_util::GetBit(data, i)) {
       ++count;
     }
   }
@@ -107,7 +108,7 @@ void TransferBitmap(const uint8_t* data, int64_t offset, int64_t length,
       writer.PutNextTrailingByte(mode == TransferMode::Invert ? ~byte : byte, valid_bits);
     }
   } else if (length) {
-    int64_t num_bytes = BitUtil::BytesForBits(length);
+    int64_t num_bytes = bit_util::BytesForBits(length);
 
     // Shift by its byte offset
     data += offset / 8;
@@ -147,11 +148,11 @@ Result<std::shared_ptr<Buffer>> TransferBitmap(MemoryPool* pool, const uint8_t*
 
   // As we have freshly allocated this bitmap, we should take care of zeroing the
   // remaining bits.
-  int64_t num_bytes = BitUtil::BytesForBits(length);
+  int64_t num_bytes = bit_util::BytesForBits(length);
   int64_t bits_to_zero = num_bytes * 8 - length;
   for (int64_t i = length; i < length + bits_to_zero; ++i) {
     // Both branches may copy extra bits - unsetting to match specification.
-    BitUtil::ClearBit(dest, i);
+    bit_util::ClearBit(dest, i);
   }
   return buffer;
 }
@@ -186,8 +187,8 @@ bool BitmapEquals(const uint8_t* left, int64_t left_offset, const uint8_t* right
       return false;
     }
     for (int64_t i = (length / 8) * 8; i < length; ++i) {
-      if (BitUtil::GetBit(left, left_offset + i) !=
-          BitUtil::GetBit(right, right_offset + i)) {
+      if (bit_util::GetBit(left, left_offset + i) !=
+          bit_util::GetBit(right, right_offset + i)) {
         return false;
       }
     }
@@ -245,7 +246,7 @@ void AlignedBitmapOp(const uint8_t* left, int64_t left_offset, const uint8_t* ri
   DCHECK_EQ(left_offset % 8, right_offset % 8);
   DCHECK_EQ(left_offset % 8, out_offset % 8);
 
-  const int64_t nbytes = BitUtil::BytesForBits(length + left_offset % 8);
+  const int64_t nbytes = bit_util::BytesForBits(length + left_offset % 8);
   left += left_offset / 8;
   right += right_offset / 8;
   out += out_offset / 8;
diff --git a/cpp/src/arrow/util/bitmap_reader.h b/cpp/src/arrow/util/bitmap_reader.h
index 55d92d15ce0..9e74fcc9f38 100644
--- a/cpp/src/arrow/util/bitmap_reader.h
+++ b/cpp/src/arrow/util/bitmap_reader.h
@@ -123,16 +123,16 @@ class BitmapUInt64Reader {
     uint64_t word;
     memcpy(&word, bitmap_, 8);
     bitmap_ += 8;
-    return BitUtil::ToLittleEndian(word);
+    return bit_util::ToLittleEndian(word);
   }
 
   uint64_t LoadPartialWord(int8_t bit_offset, int64_t num_bits) {
     uint64_t word = 0;
-    const int64_t num_bytes = BitUtil::BytesForBits(num_bits);
+    const int64_t num_bytes = bit_util::BytesForBits(num_bits);
     memcpy(&word, bitmap_, num_bytes);
     bitmap_ += num_bytes;
-    return (BitUtil::ToLittleEndian(word) >> bit_offset) &
-           BitUtil::LeastSignificantBitMask(num_bits);
+    return (bit_util::ToLittleEndian(word) >> bit_offset) &
+           bit_util::LeastSignificantBitMask(num_bits);
   }
 
   const uint8_t* bitmap_;
@@ -153,14 +153,14 @@ class BitmapWordReader {
   BitmapWordReader(const uint8_t* bitmap, int64_t offset, int64_t length)
       : offset_(static_cast<int64_t>(may_have_byte_offset) * (offset % 8)),
         bitmap_(bitmap + offset / 8),
-        bitmap_end_(bitmap_ + BitUtil::BytesForBits(offset_ + length)) {
+        bitmap_end_(bitmap_ + bit_util::BytesForBits(offset_ + length)) {
     // decrement word count by one as we may touch two adjacent words in one iteration
     nwords_ = length / (sizeof(Word) * 8) - 1;
     if (nwords_ < 0) {
       nwords_ = 0;
     }
     trailing_bits_ = static_cast<int>(length - nwords_ * sizeof(Word) * 8);
-    trailing_bytes_ = static_cast<int>(BitUtil::BytesForBits(trailing_bits_));
+    trailing_bytes_ = static_cast<int>(bit_util::BytesForBits(trailing_bits_));
 
     if (nwords_ > 0) {
       current_data.word_ = load<Word>(bitmap_);
@@ -250,7 +250,7 @@ class BitmapWordReader {
   template <typename DType>
   DType load(const uint8_t* bitmap) {
     assert(bitmap + sizeof(DType) <= bitmap_end_);
-    return BitUtil::ToLittleEndian(util::SafeLoadAs<DType>(bitmap));
+    return bit_util::ToLittleEndian(util::SafeLoadAs<DType>(bitmap));
   }
 };
 
@@ -263,7 +263,7 @@ struct OptionalBitIndexer {
       : bitmap(buffer == NULLPTR ? NULLPTR : buffer->data()), offset(offset) {}
 
   bool operator[](int64_t i) const {
-    return bitmap == NULLPTR || BitUtil::GetBit(bitmap, offset + i);
+    return bitmap == NULLPTR || bit_util::GetBit(bitmap, offset + i);
   }
 };
 
diff --git a/cpp/src/arrow/util/bitmap_reader_benchmark.cc b/cpp/src/arrow/util/bitmap_reader_benchmark.cc
index 359653c9644..1427adb13e1 100644
--- a/cpp/src/arrow/util/bitmap_reader_benchmark.cc
+++ b/cpp/src/arrow/util/bitmap_reader_benchmark.cc
@@ -31,7 +31,7 @@
 #include "benchmark/benchmark.h"
 
 namespace arrow {
-namespace BitUtil {
+namespace bit_util {
 
 using internal::BitBlockCount;
 using internal::BitBlockCounter;
@@ -109,5 +109,5 @@ static void BitmapWordReaderBench(benchmark::State& state) {
 BENCHMARK(BitBlockCounterBench)->Arg(kBufferSize);
 BENCHMARK(BitmapWordReaderBench)->Arg(kBufferSize);
 
-}  // namespace BitUtil
+}  // namespace bit_util
 }  // namespace arrow
diff --git a/cpp/src/arrow/util/bitmap_visit.h b/cpp/src/arrow/util/bitmap_visit.h
index 8a16993e052..c29589013e4 100644
--- a/cpp/src/arrow/util/bitmap_visit.h
+++ b/cpp/src/arrow/util/bitmap_visit.h
@@ -48,7 +48,7 @@ void VisitBitsUnrolled(const uint8_t* bitmap, int64_t start_offset, int64_t leng
 
   // Start by visiting any bits preceding the first full byte.
   int64_t num_bits_before_full_bytes =
-      BitUtil::RoundUpToMultipleOf8(start_offset) - start_offset;
+      bit_util::RoundUpToMultipleOf8(start_offset) - start_offset;
   // Truncate num_bits_before_full_bytes if it is greater than length.
   if (num_bits_before_full_bytes > length) {
     num_bits_before_full_bytes = length;
@@ -58,7 +58,7 @@ void VisitBitsUnrolled(const uint8_t* bitmap, int64_t start_offset, int64_t leng
 
   // Shift the start pointer to the first full byte and compute the
   // number of full bytes to be read.
-  const uint8_t* first_full_byte = bitmap + BitUtil::CeilDiv(start_offset, 8);
+  const uint8_t* first_full_byte = bitmap + bit_util::CeilDiv(start_offset, 8);
   const int64_t num_full_bytes = (length - num_bits_before_full_bytes) / 8;
 
   // Iterate over each full byte of the input bitmap and call the visitor in
@@ -68,14 +68,14 @@ void VisitBitsUnrolled(const uint8_t* bitmap, int64_t start_offset, int64_t leng
     const uint8_t byte = *(first_full_byte + byte_index);
 
     // Execute the visitor function on each bit of the current byte.
-    visit(BitUtil::GetBitFromByte(byte, 0));
-    visit(BitUtil::GetBitFromByte(byte, 1));
-    visit(BitUtil::GetBitFromByte(byte, 2));
-    visit(BitUtil::GetBitFromByte(byte, 3));
-    visit(BitUtil::GetBitFromByte(byte, 4));
-    visit(BitUtil::GetBitFromByte(byte, 5));
-    visit(BitUtil::GetBitFromByte(byte, 6));
-    visit(BitUtil::GetBitFromByte(byte, 7));
+    visit(bit_util::GetBitFromByte(byte, 0));
+    visit(bit_util::GetBitFromByte(byte, 1));
+    visit(bit_util::GetBitFromByte(byte, 2));
+    visit(bit_util::GetBitFromByte(byte, 3));
+    visit(bit_util::GetBitFromByte(byte, 4));
+    visit(bit_util::GetBitFromByte(byte, 5));
+    visit(bit_util::GetBitFromByte(byte, 6));
+    visit(bit_util::GetBitFromByte(byte, 7));
   }
 
   // Write any leftover bits in the last byte.
diff --git a/cpp/src/arrow/util/bitmap_writer.h b/cpp/src/arrow/util/bitmap_writer.h
index 1df1baa0f2e..65d0d188d7c 100644
--- a/cpp/src/arrow/util/bitmap_writer.h
+++ b/cpp/src/arrow/util/bitmap_writer.h
@@ -34,7 +34,7 @@ class BitmapWriter {
   BitmapWriter(uint8_t* bitmap, int64_t start_offset, int64_t length)
       : bitmap_(bitmap), position_(0), length_(length) {
     byte_offset_ = start_offset / 8;
-    bit_mask_ = BitUtil::kBitmask[start_offset % 8];
+    bit_mask_ = bit_util::kBitmask[start_offset % 8];
     if (length > 0) {
       current_byte_ = bitmap[byte_offset_];
     } else {
@@ -88,9 +88,10 @@ class FirstTimeBitmapWriter {
       : bitmap_(bitmap), position_(0), length_(length) {
     current_byte_ = 0;
     byte_offset_ = start_offset / 8;
-    bit_mask_ = BitUtil::kBitmask[start_offset % 8];
+    bit_mask_ = bit_util::kBitmask[start_offset % 8];
     if (length > 0) {
-      current_byte_ = bitmap[byte_offset_] & BitUtil::kPrecedingBitmask[start_offset % 8];
+      current_byte_ =
+          bitmap[byte_offset_] & bit_util::kPrecedingBitmask[start_offset % 8];
     } else {
       current_byte_ = 0;
     }
@@ -111,8 +112,8 @@ class FirstTimeBitmapWriter {
 
     // Update state variables except for current_byte_ here.
     position_ += number_of_bits;
-    int64_t bit_offset = BitUtil::CountTrailingZeros(static_cast<uint32_t>(bit_mask_));
-    bit_mask_ = BitUtil::kBitmask[(bit_offset + number_of_bits) % 8];
+    int64_t bit_offset = bit_util::CountTrailingZeros(static_cast<uint32_t>(bit_mask_));
+    bit_mask_ = bit_util::kBitmask[(bit_offset + number_of_bits) % 8];
     byte_offset_ += (bit_offset + number_of_bits) / 8;
 
     if (bit_offset != 0) {
@@ -122,7 +123,7 @@ class FirstTimeBitmapWriter {
       // Carry over bits from word to current_byte_. We assume any extra bits in word
       // unset so no additional accounting is needed for when number_of_bits <
       // bits_to_carry.
-      current_byte_ |= (word & BitUtil::kPrecedingBitmask[bits_to_carry]) << bit_offset;
+      current_byte_ |= (word & bit_util::kPrecedingBitmask[bits_to_carry]) << bit_offset;
       // Check if everything is transfered into current_byte_.
       if (ARROW_PREDICT_FALSE(number_of_bits < bits_to_carry)) {
         return;
@@ -133,8 +134,8 @@ class FirstTimeBitmapWriter {
       word = word >> bits_to_carry;
       number_of_bits -= bits_to_carry;
     }
-    word = BitUtil::ToLittleEndian(word);
-    int64_t bytes_for_word = ::arrow::BitUtil::BytesForBits(number_of_bits);
+    word = bit_util::ToLittleEndian(word);
+    int64_t bytes_for_word = ::arrow::bit_util::BytesForBits(number_of_bits);
     std::memcpy(append_position, &word, bytes_for_word);
     // At this point, the previous current_byte_ has been written to bitmap_.
     // The new current_byte_ is either the last relevant byte in 'word'
@@ -187,7 +188,7 @@ class BitmapWordWriter {
   BitmapWordWriter(uint8_t* bitmap, int64_t offset, int64_t length)
       : offset_(static_cast<int64_t>(may_have_byte_offset) * (offset % 8)),
         bitmap_(bitmap + offset / 8),
-        bitmap_end_(bitmap_ + BitUtil::BytesForBits(offset_ + length)),
+        bitmap_end_(bitmap_ + bit_util::BytesForBits(offset_ + length)),
         mask_((1U << offset_) - 1) {
     if (offset_) {
       if (length >= static_cast<int>(sizeof(Word) * 8)) {
@@ -241,7 +242,7 @@ class BitmapWordWriter {
     } else {
       assert(valid_bits > 0);
       assert(valid_bits < 8);
-      assert(bitmap_ + BitUtil::BytesForBits(offset_ + valid_bits) <= bitmap_end_);
+      assert(bitmap_ + bit_util::BytesForBits(offset_ + valid_bits) <= bitmap_end_);
       internal::BitmapWriter writer(bitmap_, offset_, valid_bits);
       for (int i = 0; i < valid_bits; ++i) {
         (byte & 0x01) ? writer.Set() : writer.Clear();
@@ -271,13 +272,13 @@ class BitmapWordWriter {
   template <typename DType>
   DType load(const uint8_t* bitmap) {
     assert(bitmap + sizeof(DType) <= bitmap_end_);
-    return BitUtil::ToLittleEndian(util::SafeLoadAs<DType>(bitmap));
+    return bit_util::ToLittleEndian(util::SafeLoadAs<DType>(bitmap));
   }
 
   template <typename DType>
   void store(uint8_t* bitmap, DType data) {
     assert(bitmap + sizeof(DType) <= bitmap_end_);
-    util::SafeStore(bitmap, BitUtil::FromLittleEndian(data));
+    util::SafeStore(bitmap, bit_util::FromLittleEndian(data));
   }
 };
 
diff --git a/cpp/src/arrow/util/bpacking64_default.h b/cpp/src/arrow/util/bpacking64_default.h
index 81189cb58eb..4f45619b2a7 100644
--- a/cpp/src/arrow/util/bpacking64_default.h
+++ b/cpp/src/arrow/util/bpacking64_default.h
@@ -42,7 +42,7 @@ inline const uint8_t* unpack0_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack1_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 1ULL;
   uint64_t w0 = util::SafeLoadAs<uint32_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 1) & mask;
@@ -83,7 +83,7 @@ inline const uint8_t* unpack1_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack2_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 3ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 2) & mask;
@@ -124,10 +124,10 @@ inline const uint8_t* unpack2_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack3_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 7ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint32_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 3) & mask;
@@ -168,10 +168,10 @@ inline const uint8_t* unpack3_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack4_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 15ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 4) & mask;
@@ -212,13 +212,13 @@ inline const uint8_t* unpack4_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack5_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 31ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint32_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 5) & mask;
@@ -259,13 +259,13 @@ inline const uint8_t* unpack5_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack6_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 63ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 6) & mask;
@@ -306,16 +306,16 @@ inline const uint8_t* unpack6_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack7_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 127ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint32_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 7) & mask;
@@ -356,16 +356,16 @@ inline const uint8_t* unpack7_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack8_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 255ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 8) & mask;
@@ -406,19 +406,19 @@ inline const uint8_t* unpack8_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack9_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 511ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint32_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 9) & mask;
@@ -459,19 +459,19 @@ inline const uint8_t* unpack9_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack10_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 1023ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 10) & mask;
@@ -512,22 +512,22 @@ inline const uint8_t* unpack10_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack11_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 2047ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint32_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 11) & mask;
@@ -568,22 +568,22 @@ inline const uint8_t* unpack11_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack12_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 4095ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 12) & mask;
@@ -624,25 +624,25 @@ inline const uint8_t* unpack12_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack13_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 8191ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint32_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 13) & mask;
@@ -683,25 +683,25 @@ inline const uint8_t* unpack13_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack14_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 16383ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 14) & mask;
@@ -742,28 +742,28 @@ inline const uint8_t* unpack14_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack15_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 32767ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint32_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 15) & mask;
@@ -804,28 +804,28 @@ inline const uint8_t* unpack15_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack16_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 65535ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 16) & mask;
@@ -866,31 +866,31 @@ inline const uint8_t* unpack16_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack17_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 131071ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint32_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 17) & mask;
@@ -931,31 +931,31 @@ inline const uint8_t* unpack17_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack18_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 262143ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 18) & mask;
@@ -996,34 +996,34 @@ inline const uint8_t* unpack18_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack19_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 524287ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint32_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 19) & mask;
@@ -1064,34 +1064,34 @@ inline const uint8_t* unpack19_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack20_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 1048575ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 20) & mask;
@@ -1132,37 +1132,37 @@ inline const uint8_t* unpack20_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack21_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 2097151ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint32_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 21) & mask;
@@ -1203,37 +1203,37 @@ inline const uint8_t* unpack21_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack22_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 4194303ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 22) & mask;
@@ -1274,40 +1274,40 @@ inline const uint8_t* unpack22_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack23_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 8388607ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint32_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 23) & mask;
@@ -1348,40 +1348,40 @@ inline const uint8_t* unpack23_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack24_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 16777215ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 24) & mask;
@@ -1422,43 +1422,43 @@ inline const uint8_t* unpack24_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack25_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 33554431ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint32_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 25) & mask;
@@ -1499,43 +1499,43 @@ inline const uint8_t* unpack25_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack26_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 67108863ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 26) & mask;
@@ -1576,46 +1576,46 @@ inline const uint8_t* unpack26_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack27_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 134217727ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint32_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 27) & mask;
@@ -1656,46 +1656,46 @@ inline const uint8_t* unpack27_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack28_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 268435455ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 28) & mask;
@@ -1736,49 +1736,49 @@ inline const uint8_t* unpack28_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack29_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 536870911ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint32_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 29) & mask;
@@ -1819,49 +1819,49 @@ inline const uint8_t* unpack29_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack30_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 1073741823ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 30) & mask;
@@ -1902,52 +1902,52 @@ inline const uint8_t* unpack30_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack31_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 2147483647ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint32_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = (w0 >> 31) & mask;
@@ -1988,52 +1988,52 @@ inline const uint8_t* unpack31_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack32_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 4294967295ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = w0 >> 32;
@@ -2074,55 +2074,55 @@ inline const uint8_t* unpack32_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack33_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 8589934591ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint32_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 33) | (w1 << 31)) & mask;
@@ -2163,55 +2163,55 @@ inline const uint8_t* unpack33_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack34_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 17179869183ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 34) | (w1 << 30)) & mask;
@@ -2252,58 +2252,58 @@ inline const uint8_t* unpack34_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack35_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 34359738367ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint32_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 35) | (w1 << 29)) & mask;
@@ -2344,58 +2344,58 @@ inline const uint8_t* unpack35_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack36_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 68719476735ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 36) | (w1 << 28)) & mask;
@@ -2436,61 +2436,61 @@ inline const uint8_t* unpack36_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack37_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 137438953471ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint32_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 37) | (w1 << 27)) & mask;
@@ -2531,61 +2531,61 @@ inline const uint8_t* unpack37_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack38_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 274877906943ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 38) | (w1 << 26)) & mask;
@@ -2626,64 +2626,64 @@ inline const uint8_t* unpack38_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack39_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 549755813887ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint32_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 39) | (w1 << 25)) & mask;
@@ -2724,64 +2724,64 @@ inline const uint8_t* unpack39_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack40_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 1099511627775ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 40) | (w1 << 24)) & mask;
@@ -2822,67 +2822,67 @@ inline const uint8_t* unpack40_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack41_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 2199023255551ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint32_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 41) | (w1 << 23)) & mask;
@@ -2923,67 +2923,67 @@ inline const uint8_t* unpack41_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack42_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 4398046511103ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 42) | (w1 << 22)) & mask;
@@ -3024,70 +3024,70 @@ inline const uint8_t* unpack42_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack43_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 8796093022207ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint32_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 43) | (w1 << 21)) & mask;
@@ -3128,70 +3128,70 @@ inline const uint8_t* unpack43_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack44_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 17592186044415ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 44) | (w1 << 20)) & mask;
@@ -3232,73 +3232,73 @@ inline const uint8_t* unpack44_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack45_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 35184372088831ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint32_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 45) | (w1 << 19)) & mask;
@@ -3339,73 +3339,73 @@ inline const uint8_t* unpack45_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack46_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 70368744177663ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 46) | (w1 << 18)) & mask;
@@ -3446,76 +3446,76 @@ inline const uint8_t* unpack46_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack47_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 140737488355327ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   uint64_t w23 = util::SafeLoadAs<uint32_t>(in);
-  w23 = arrow::BitUtil::FromLittleEndian(w23);
+  w23 = arrow::bit_util::FromLittleEndian(w23);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 47) | (w1 << 17)) & mask;
@@ -3556,76 +3556,76 @@ inline const uint8_t* unpack47_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack48_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 281474976710655ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   uint64_t w23 = util::SafeLoadAs<uint64_t>(in);
-  w23 = arrow::BitUtil::FromLittleEndian(w23);
+  w23 = arrow::bit_util::FromLittleEndian(w23);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 48) | (w1 << 16)) & mask;
@@ -3666,79 +3666,79 @@ inline const uint8_t* unpack48_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack49_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 562949953421311ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   uint64_t w23 = util::SafeLoadAs<uint64_t>(in);
-  w23 = arrow::BitUtil::FromLittleEndian(w23);
+  w23 = arrow::bit_util::FromLittleEndian(w23);
   in += 8;
   uint64_t w24 = util::SafeLoadAs<uint32_t>(in);
-  w24 = arrow::BitUtil::FromLittleEndian(w24);
+  w24 = arrow::bit_util::FromLittleEndian(w24);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 49) | (w1 << 15)) & mask;
@@ -3779,79 +3779,79 @@ inline const uint8_t* unpack49_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack50_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 1125899906842623ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   uint64_t w23 = util::SafeLoadAs<uint64_t>(in);
-  w23 = arrow::BitUtil::FromLittleEndian(w23);
+  w23 = arrow::bit_util::FromLittleEndian(w23);
   in += 8;
   uint64_t w24 = util::SafeLoadAs<uint64_t>(in);
-  w24 = arrow::BitUtil::FromLittleEndian(w24);
+  w24 = arrow::bit_util::FromLittleEndian(w24);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 50) | (w1 << 14)) & mask;
@@ -3892,82 +3892,82 @@ inline const uint8_t* unpack50_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack51_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 2251799813685247ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   uint64_t w23 = util::SafeLoadAs<uint64_t>(in);
-  w23 = arrow::BitUtil::FromLittleEndian(w23);
+  w23 = arrow::bit_util::FromLittleEndian(w23);
   in += 8;
   uint64_t w24 = util::SafeLoadAs<uint64_t>(in);
-  w24 = arrow::BitUtil::FromLittleEndian(w24);
+  w24 = arrow::bit_util::FromLittleEndian(w24);
   in += 8;
   uint64_t w25 = util::SafeLoadAs<uint32_t>(in);
-  w25 = arrow::BitUtil::FromLittleEndian(w25);
+  w25 = arrow::bit_util::FromLittleEndian(w25);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 51) | (w1 << 13)) & mask;
@@ -4008,82 +4008,82 @@ inline const uint8_t* unpack51_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack52_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 4503599627370495ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   uint64_t w23 = util::SafeLoadAs<uint64_t>(in);
-  w23 = arrow::BitUtil::FromLittleEndian(w23);
+  w23 = arrow::bit_util::FromLittleEndian(w23);
   in += 8;
   uint64_t w24 = util::SafeLoadAs<uint64_t>(in);
-  w24 = arrow::BitUtil::FromLittleEndian(w24);
+  w24 = arrow::bit_util::FromLittleEndian(w24);
   in += 8;
   uint64_t w25 = util::SafeLoadAs<uint64_t>(in);
-  w25 = arrow::BitUtil::FromLittleEndian(w25);
+  w25 = arrow::bit_util::FromLittleEndian(w25);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 52) | (w1 << 12)) & mask;
@@ -4124,85 +4124,85 @@ inline const uint8_t* unpack52_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack53_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 9007199254740991ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   uint64_t w23 = util::SafeLoadAs<uint64_t>(in);
-  w23 = arrow::BitUtil::FromLittleEndian(w23);
+  w23 = arrow::bit_util::FromLittleEndian(w23);
   in += 8;
   uint64_t w24 = util::SafeLoadAs<uint64_t>(in);
-  w24 = arrow::BitUtil::FromLittleEndian(w24);
+  w24 = arrow::bit_util::FromLittleEndian(w24);
   in += 8;
   uint64_t w25 = util::SafeLoadAs<uint64_t>(in);
-  w25 = arrow::BitUtil::FromLittleEndian(w25);
+  w25 = arrow::bit_util::FromLittleEndian(w25);
   in += 8;
   uint64_t w26 = util::SafeLoadAs<uint32_t>(in);
-  w26 = arrow::BitUtil::FromLittleEndian(w26);
+  w26 = arrow::bit_util::FromLittleEndian(w26);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 53) | (w1 << 11)) & mask;
@@ -4243,85 +4243,85 @@ inline const uint8_t* unpack53_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack54_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 18014398509481983ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   uint64_t w23 = util::SafeLoadAs<uint64_t>(in);
-  w23 = arrow::BitUtil::FromLittleEndian(w23);
+  w23 = arrow::bit_util::FromLittleEndian(w23);
   in += 8;
   uint64_t w24 = util::SafeLoadAs<uint64_t>(in);
-  w24 = arrow::BitUtil::FromLittleEndian(w24);
+  w24 = arrow::bit_util::FromLittleEndian(w24);
   in += 8;
   uint64_t w25 = util::SafeLoadAs<uint64_t>(in);
-  w25 = arrow::BitUtil::FromLittleEndian(w25);
+  w25 = arrow::bit_util::FromLittleEndian(w25);
   in += 8;
   uint64_t w26 = util::SafeLoadAs<uint64_t>(in);
-  w26 = arrow::BitUtil::FromLittleEndian(w26);
+  w26 = arrow::bit_util::FromLittleEndian(w26);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 54) | (w1 << 10)) & mask;
@@ -4362,88 +4362,88 @@ inline const uint8_t* unpack54_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack55_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 36028797018963967ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   uint64_t w23 = util::SafeLoadAs<uint64_t>(in);
-  w23 = arrow::BitUtil::FromLittleEndian(w23);
+  w23 = arrow::bit_util::FromLittleEndian(w23);
   in += 8;
   uint64_t w24 = util::SafeLoadAs<uint64_t>(in);
-  w24 = arrow::BitUtil::FromLittleEndian(w24);
+  w24 = arrow::bit_util::FromLittleEndian(w24);
   in += 8;
   uint64_t w25 = util::SafeLoadAs<uint64_t>(in);
-  w25 = arrow::BitUtil::FromLittleEndian(w25);
+  w25 = arrow::bit_util::FromLittleEndian(w25);
   in += 8;
   uint64_t w26 = util::SafeLoadAs<uint64_t>(in);
-  w26 = arrow::BitUtil::FromLittleEndian(w26);
+  w26 = arrow::bit_util::FromLittleEndian(w26);
   in += 8;
   uint64_t w27 = util::SafeLoadAs<uint32_t>(in);
-  w27 = arrow::BitUtil::FromLittleEndian(w27);
+  w27 = arrow::bit_util::FromLittleEndian(w27);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 55) | (w1 << 9)) & mask;
@@ -4484,88 +4484,88 @@ inline const uint8_t* unpack55_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack56_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 72057594037927935ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   uint64_t w23 = util::SafeLoadAs<uint64_t>(in);
-  w23 = arrow::BitUtil::FromLittleEndian(w23);
+  w23 = arrow::bit_util::FromLittleEndian(w23);
   in += 8;
   uint64_t w24 = util::SafeLoadAs<uint64_t>(in);
-  w24 = arrow::BitUtil::FromLittleEndian(w24);
+  w24 = arrow::bit_util::FromLittleEndian(w24);
   in += 8;
   uint64_t w25 = util::SafeLoadAs<uint64_t>(in);
-  w25 = arrow::BitUtil::FromLittleEndian(w25);
+  w25 = arrow::bit_util::FromLittleEndian(w25);
   in += 8;
   uint64_t w26 = util::SafeLoadAs<uint64_t>(in);
-  w26 = arrow::BitUtil::FromLittleEndian(w26);
+  w26 = arrow::bit_util::FromLittleEndian(w26);
   in += 8;
   uint64_t w27 = util::SafeLoadAs<uint64_t>(in);
-  w27 = arrow::BitUtil::FromLittleEndian(w27);
+  w27 = arrow::bit_util::FromLittleEndian(w27);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 56) | (w1 << 8)) & mask;
@@ -4606,91 +4606,91 @@ inline const uint8_t* unpack56_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack57_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 144115188075855871ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   uint64_t w23 = util::SafeLoadAs<uint64_t>(in);
-  w23 = arrow::BitUtil::FromLittleEndian(w23);
+  w23 = arrow::bit_util::FromLittleEndian(w23);
   in += 8;
   uint64_t w24 = util::SafeLoadAs<uint64_t>(in);
-  w24 = arrow::BitUtil::FromLittleEndian(w24);
+  w24 = arrow::bit_util::FromLittleEndian(w24);
   in += 8;
   uint64_t w25 = util::SafeLoadAs<uint64_t>(in);
-  w25 = arrow::BitUtil::FromLittleEndian(w25);
+  w25 = arrow::bit_util::FromLittleEndian(w25);
   in += 8;
   uint64_t w26 = util::SafeLoadAs<uint64_t>(in);
-  w26 = arrow::BitUtil::FromLittleEndian(w26);
+  w26 = arrow::bit_util::FromLittleEndian(w26);
   in += 8;
   uint64_t w27 = util::SafeLoadAs<uint64_t>(in);
-  w27 = arrow::BitUtil::FromLittleEndian(w27);
+  w27 = arrow::bit_util::FromLittleEndian(w27);
   in += 8;
   uint64_t w28 = util::SafeLoadAs<uint32_t>(in);
-  w28 = arrow::BitUtil::FromLittleEndian(w28);
+  w28 = arrow::bit_util::FromLittleEndian(w28);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 57) | (w1 << 7)) & mask;
@@ -4731,91 +4731,91 @@ inline const uint8_t* unpack57_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack58_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 288230376151711743ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   uint64_t w23 = util::SafeLoadAs<uint64_t>(in);
-  w23 = arrow::BitUtil::FromLittleEndian(w23);
+  w23 = arrow::bit_util::FromLittleEndian(w23);
   in += 8;
   uint64_t w24 = util::SafeLoadAs<uint64_t>(in);
-  w24 = arrow::BitUtil::FromLittleEndian(w24);
+  w24 = arrow::bit_util::FromLittleEndian(w24);
   in += 8;
   uint64_t w25 = util::SafeLoadAs<uint64_t>(in);
-  w25 = arrow::BitUtil::FromLittleEndian(w25);
+  w25 = arrow::bit_util::FromLittleEndian(w25);
   in += 8;
   uint64_t w26 = util::SafeLoadAs<uint64_t>(in);
-  w26 = arrow::BitUtil::FromLittleEndian(w26);
+  w26 = arrow::bit_util::FromLittleEndian(w26);
   in += 8;
   uint64_t w27 = util::SafeLoadAs<uint64_t>(in);
-  w27 = arrow::BitUtil::FromLittleEndian(w27);
+  w27 = arrow::bit_util::FromLittleEndian(w27);
   in += 8;
   uint64_t w28 = util::SafeLoadAs<uint64_t>(in);
-  w28 = arrow::BitUtil::FromLittleEndian(w28);
+  w28 = arrow::bit_util::FromLittleEndian(w28);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 58) | (w1 << 6)) & mask;
@@ -4856,94 +4856,94 @@ inline const uint8_t* unpack58_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack59_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 576460752303423487ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   uint64_t w23 = util::SafeLoadAs<uint64_t>(in);
-  w23 = arrow::BitUtil::FromLittleEndian(w23);
+  w23 = arrow::bit_util::FromLittleEndian(w23);
   in += 8;
   uint64_t w24 = util::SafeLoadAs<uint64_t>(in);
-  w24 = arrow::BitUtil::FromLittleEndian(w24);
+  w24 = arrow::bit_util::FromLittleEndian(w24);
   in += 8;
   uint64_t w25 = util::SafeLoadAs<uint64_t>(in);
-  w25 = arrow::BitUtil::FromLittleEndian(w25);
+  w25 = arrow::bit_util::FromLittleEndian(w25);
   in += 8;
   uint64_t w26 = util::SafeLoadAs<uint64_t>(in);
-  w26 = arrow::BitUtil::FromLittleEndian(w26);
+  w26 = arrow::bit_util::FromLittleEndian(w26);
   in += 8;
   uint64_t w27 = util::SafeLoadAs<uint64_t>(in);
-  w27 = arrow::BitUtil::FromLittleEndian(w27);
+  w27 = arrow::bit_util::FromLittleEndian(w27);
   in += 8;
   uint64_t w28 = util::SafeLoadAs<uint64_t>(in);
-  w28 = arrow::BitUtil::FromLittleEndian(w28);
+  w28 = arrow::bit_util::FromLittleEndian(w28);
   in += 8;
   uint64_t w29 = util::SafeLoadAs<uint32_t>(in);
-  w29 = arrow::BitUtil::FromLittleEndian(w29);
+  w29 = arrow::bit_util::FromLittleEndian(w29);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 59) | (w1 << 5)) & mask;
@@ -4984,94 +4984,94 @@ inline const uint8_t* unpack59_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack60_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 1152921504606846975ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   uint64_t w23 = util::SafeLoadAs<uint64_t>(in);
-  w23 = arrow::BitUtil::FromLittleEndian(w23);
+  w23 = arrow::bit_util::FromLittleEndian(w23);
   in += 8;
   uint64_t w24 = util::SafeLoadAs<uint64_t>(in);
-  w24 = arrow::BitUtil::FromLittleEndian(w24);
+  w24 = arrow::bit_util::FromLittleEndian(w24);
   in += 8;
   uint64_t w25 = util::SafeLoadAs<uint64_t>(in);
-  w25 = arrow::BitUtil::FromLittleEndian(w25);
+  w25 = arrow::bit_util::FromLittleEndian(w25);
   in += 8;
   uint64_t w26 = util::SafeLoadAs<uint64_t>(in);
-  w26 = arrow::BitUtil::FromLittleEndian(w26);
+  w26 = arrow::bit_util::FromLittleEndian(w26);
   in += 8;
   uint64_t w27 = util::SafeLoadAs<uint64_t>(in);
-  w27 = arrow::BitUtil::FromLittleEndian(w27);
+  w27 = arrow::bit_util::FromLittleEndian(w27);
   in += 8;
   uint64_t w28 = util::SafeLoadAs<uint64_t>(in);
-  w28 = arrow::BitUtil::FromLittleEndian(w28);
+  w28 = arrow::bit_util::FromLittleEndian(w28);
   in += 8;
   uint64_t w29 = util::SafeLoadAs<uint64_t>(in);
-  w29 = arrow::BitUtil::FromLittleEndian(w29);
+  w29 = arrow::bit_util::FromLittleEndian(w29);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 60) | (w1 << 4)) & mask;
@@ -5112,97 +5112,97 @@ inline const uint8_t* unpack60_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack61_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 2305843009213693951ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   uint64_t w23 = util::SafeLoadAs<uint64_t>(in);
-  w23 = arrow::BitUtil::FromLittleEndian(w23);
+  w23 = arrow::bit_util::FromLittleEndian(w23);
   in += 8;
   uint64_t w24 = util::SafeLoadAs<uint64_t>(in);
-  w24 = arrow::BitUtil::FromLittleEndian(w24);
+  w24 = arrow::bit_util::FromLittleEndian(w24);
   in += 8;
   uint64_t w25 = util::SafeLoadAs<uint64_t>(in);
-  w25 = arrow::BitUtil::FromLittleEndian(w25);
+  w25 = arrow::bit_util::FromLittleEndian(w25);
   in += 8;
   uint64_t w26 = util::SafeLoadAs<uint64_t>(in);
-  w26 = arrow::BitUtil::FromLittleEndian(w26);
+  w26 = arrow::bit_util::FromLittleEndian(w26);
   in += 8;
   uint64_t w27 = util::SafeLoadAs<uint64_t>(in);
-  w27 = arrow::BitUtil::FromLittleEndian(w27);
+  w27 = arrow::bit_util::FromLittleEndian(w27);
   in += 8;
   uint64_t w28 = util::SafeLoadAs<uint64_t>(in);
-  w28 = arrow::BitUtil::FromLittleEndian(w28);
+  w28 = arrow::bit_util::FromLittleEndian(w28);
   in += 8;
   uint64_t w29 = util::SafeLoadAs<uint64_t>(in);
-  w29 = arrow::BitUtil::FromLittleEndian(w29);
+  w29 = arrow::bit_util::FromLittleEndian(w29);
   in += 8;
   uint64_t w30 = util::SafeLoadAs<uint32_t>(in);
-  w30 = arrow::BitUtil::FromLittleEndian(w30);
+  w30 = arrow::bit_util::FromLittleEndian(w30);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 61) | (w1 << 3)) & mask;
@@ -5243,97 +5243,97 @@ inline const uint8_t* unpack61_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack62_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 4611686018427387903ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   uint64_t w23 = util::SafeLoadAs<uint64_t>(in);
-  w23 = arrow::BitUtil::FromLittleEndian(w23);
+  w23 = arrow::bit_util::FromLittleEndian(w23);
   in += 8;
   uint64_t w24 = util::SafeLoadAs<uint64_t>(in);
-  w24 = arrow::BitUtil::FromLittleEndian(w24);
+  w24 = arrow::bit_util::FromLittleEndian(w24);
   in += 8;
   uint64_t w25 = util::SafeLoadAs<uint64_t>(in);
-  w25 = arrow::BitUtil::FromLittleEndian(w25);
+  w25 = arrow::bit_util::FromLittleEndian(w25);
   in += 8;
   uint64_t w26 = util::SafeLoadAs<uint64_t>(in);
-  w26 = arrow::BitUtil::FromLittleEndian(w26);
+  w26 = arrow::bit_util::FromLittleEndian(w26);
   in += 8;
   uint64_t w27 = util::SafeLoadAs<uint64_t>(in);
-  w27 = arrow::BitUtil::FromLittleEndian(w27);
+  w27 = arrow::bit_util::FromLittleEndian(w27);
   in += 8;
   uint64_t w28 = util::SafeLoadAs<uint64_t>(in);
-  w28 = arrow::BitUtil::FromLittleEndian(w28);
+  w28 = arrow::bit_util::FromLittleEndian(w28);
   in += 8;
   uint64_t w29 = util::SafeLoadAs<uint64_t>(in);
-  w29 = arrow::BitUtil::FromLittleEndian(w29);
+  w29 = arrow::bit_util::FromLittleEndian(w29);
   in += 8;
   uint64_t w30 = util::SafeLoadAs<uint64_t>(in);
-  w30 = arrow::BitUtil::FromLittleEndian(w30);
+  w30 = arrow::bit_util::FromLittleEndian(w30);
   in += 8;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 62) | (w1 << 2)) & mask;
@@ -5374,100 +5374,100 @@ inline const uint8_t* unpack62_64(const uint8_t* in, uint64_t* out) {
 inline const uint8_t* unpack63_64(const uint8_t* in, uint64_t* out) {
   const uint64_t mask = 9223372036854775807ULL;
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   uint64_t w23 = util::SafeLoadAs<uint64_t>(in);
-  w23 = arrow::BitUtil::FromLittleEndian(w23);
+  w23 = arrow::bit_util::FromLittleEndian(w23);
   in += 8;
   uint64_t w24 = util::SafeLoadAs<uint64_t>(in);
-  w24 = arrow::BitUtil::FromLittleEndian(w24);
+  w24 = arrow::bit_util::FromLittleEndian(w24);
   in += 8;
   uint64_t w25 = util::SafeLoadAs<uint64_t>(in);
-  w25 = arrow::BitUtil::FromLittleEndian(w25);
+  w25 = arrow::bit_util::FromLittleEndian(w25);
   in += 8;
   uint64_t w26 = util::SafeLoadAs<uint64_t>(in);
-  w26 = arrow::BitUtil::FromLittleEndian(w26);
+  w26 = arrow::bit_util::FromLittleEndian(w26);
   in += 8;
   uint64_t w27 = util::SafeLoadAs<uint64_t>(in);
-  w27 = arrow::BitUtil::FromLittleEndian(w27);
+  w27 = arrow::bit_util::FromLittleEndian(w27);
   in += 8;
   uint64_t w28 = util::SafeLoadAs<uint64_t>(in);
-  w28 = arrow::BitUtil::FromLittleEndian(w28);
+  w28 = arrow::bit_util::FromLittleEndian(w28);
   in += 8;
   uint64_t w29 = util::SafeLoadAs<uint64_t>(in);
-  w29 = arrow::BitUtil::FromLittleEndian(w29);
+  w29 = arrow::bit_util::FromLittleEndian(w29);
   in += 8;
   uint64_t w30 = util::SafeLoadAs<uint64_t>(in);
-  w30 = arrow::BitUtil::FromLittleEndian(w30);
+  w30 = arrow::bit_util::FromLittleEndian(w30);
   in += 8;
   uint64_t w31 = util::SafeLoadAs<uint32_t>(in);
-  w31 = arrow::BitUtil::FromLittleEndian(w31);
+  w31 = arrow::bit_util::FromLittleEndian(w31);
   in += 4;
   out[0] = (w0)&mask;
   out[1] = ((w0 >> 63) | (w1 << 1)) & mask;
@@ -5507,100 +5507,100 @@ inline const uint8_t* unpack63_64(const uint8_t* in, uint64_t* out) {
 
 inline const uint8_t* unpack64_64(const uint8_t* in, uint64_t* out) {
   uint64_t w0 = util::SafeLoadAs<uint64_t>(in);
-  w0 = arrow::BitUtil::FromLittleEndian(w0);
+  w0 = arrow::bit_util::FromLittleEndian(w0);
   in += 8;
   uint64_t w1 = util::SafeLoadAs<uint64_t>(in);
-  w1 = arrow::BitUtil::FromLittleEndian(w1);
+  w1 = arrow::bit_util::FromLittleEndian(w1);
   in += 8;
   uint64_t w2 = util::SafeLoadAs<uint64_t>(in);
-  w2 = arrow::BitUtil::FromLittleEndian(w2);
+  w2 = arrow::bit_util::FromLittleEndian(w2);
   in += 8;
   uint64_t w3 = util::SafeLoadAs<uint64_t>(in);
-  w3 = arrow::BitUtil::FromLittleEndian(w3);
+  w3 = arrow::bit_util::FromLittleEndian(w3);
   in += 8;
   uint64_t w4 = util::SafeLoadAs<uint64_t>(in);
-  w4 = arrow::BitUtil::FromLittleEndian(w4);
+  w4 = arrow::bit_util::FromLittleEndian(w4);
   in += 8;
   uint64_t w5 = util::SafeLoadAs<uint64_t>(in);
-  w5 = arrow::BitUtil::FromLittleEndian(w5);
+  w5 = arrow::bit_util::FromLittleEndian(w5);
   in += 8;
   uint64_t w6 = util::SafeLoadAs<uint64_t>(in);
-  w6 = arrow::BitUtil::FromLittleEndian(w6);
+  w6 = arrow::bit_util::FromLittleEndian(w6);
   in += 8;
   uint64_t w7 = util::SafeLoadAs<uint64_t>(in);
-  w7 = arrow::BitUtil::FromLittleEndian(w7);
+  w7 = arrow::bit_util::FromLittleEndian(w7);
   in += 8;
   uint64_t w8 = util::SafeLoadAs<uint64_t>(in);
-  w8 = arrow::BitUtil::FromLittleEndian(w8);
+  w8 = arrow::bit_util::FromLittleEndian(w8);
   in += 8;
   uint64_t w9 = util::SafeLoadAs<uint64_t>(in);
-  w9 = arrow::BitUtil::FromLittleEndian(w9);
+  w9 = arrow::bit_util::FromLittleEndian(w9);
   in += 8;
   uint64_t w10 = util::SafeLoadAs<uint64_t>(in);
-  w10 = arrow::BitUtil::FromLittleEndian(w10);
+  w10 = arrow::bit_util::FromLittleEndian(w10);
   in += 8;
   uint64_t w11 = util::SafeLoadAs<uint64_t>(in);
-  w11 = arrow::BitUtil::FromLittleEndian(w11);
+  w11 = arrow::bit_util::FromLittleEndian(w11);
   in += 8;
   uint64_t w12 = util::SafeLoadAs<uint64_t>(in);
-  w12 = arrow::BitUtil::FromLittleEndian(w12);
+  w12 = arrow::bit_util::FromLittleEndian(w12);
   in += 8;
   uint64_t w13 = util::SafeLoadAs<uint64_t>(in);
-  w13 = arrow::BitUtil::FromLittleEndian(w13);
+  w13 = arrow::bit_util::FromLittleEndian(w13);
   in += 8;
   uint64_t w14 = util::SafeLoadAs<uint64_t>(in);
-  w14 = arrow::BitUtil::FromLittleEndian(w14);
+  w14 = arrow::bit_util::FromLittleEndian(w14);
   in += 8;
   uint64_t w15 = util::SafeLoadAs<uint64_t>(in);
-  w15 = arrow::BitUtil::FromLittleEndian(w15);
+  w15 = arrow::bit_util::FromLittleEndian(w15);
   in += 8;
   uint64_t w16 = util::SafeLoadAs<uint64_t>(in);
-  w16 = arrow::BitUtil::FromLittleEndian(w16);
+  w16 = arrow::bit_util::FromLittleEndian(w16);
   in += 8;
   uint64_t w17 = util::SafeLoadAs<uint64_t>(in);
-  w17 = arrow::BitUtil::FromLittleEndian(w17);
+  w17 = arrow::bit_util::FromLittleEndian(w17);
   in += 8;
   uint64_t w18 = util::SafeLoadAs<uint64_t>(in);
-  w18 = arrow::BitUtil::FromLittleEndian(w18);
+  w18 = arrow::bit_util::FromLittleEndian(w18);
   in += 8;
   uint64_t w19 = util::SafeLoadAs<uint64_t>(in);
-  w19 = arrow::BitUtil::FromLittleEndian(w19);
+  w19 = arrow::bit_util::FromLittleEndian(w19);
   in += 8;
   uint64_t w20 = util::SafeLoadAs<uint64_t>(in);
-  w20 = arrow::BitUtil::FromLittleEndian(w20);
+  w20 = arrow::bit_util::FromLittleEndian(w20);
   in += 8;
   uint64_t w21 = util::SafeLoadAs<uint64_t>(in);
-  w21 = arrow::BitUtil::FromLittleEndian(w21);
+  w21 = arrow::bit_util::FromLittleEndian(w21);
   in += 8;
   uint64_t w22 = util::SafeLoadAs<uint64_t>(in);
-  w22 = arrow::BitUtil::FromLittleEndian(w22);
+  w22 = arrow::bit_util::FromLittleEndian(w22);
   in += 8;
   uint64_t w23 = util::SafeLoadAs<uint64_t>(in);
-  w23 = arrow::BitUtil::FromLittleEndian(w23);
+  w23 = arrow::bit_util::FromLittleEndian(w23);
   in += 8;
   uint64_t w24 = util::SafeLoadAs<uint64_t>(in);
-  w24 = arrow::BitUtil::FromLittleEndian(w24);
+  w24 = arrow::bit_util::FromLittleEndian(w24);
   in += 8;
   uint64_t w25 = util::SafeLoadAs<uint64_t>(in);
-  w25 = arrow::BitUtil::FromLittleEndian(w25);
+  w25 = arrow::bit_util::FromLittleEndian(w25);
   in += 8;
   uint64_t w26 = util::SafeLoadAs<uint64_t>(in);
-  w26 = arrow::BitUtil::FromLittleEndian(w26);
+  w26 = arrow::bit_util::FromLittleEndian(w26);
   in += 8;
   uint64_t w27 = util::SafeLoadAs<uint64_t>(in);
-  w27 = arrow::BitUtil::FromLittleEndian(w27);
+  w27 = arrow::bit_util::FromLittleEndian(w27);
   in += 8;
   uint64_t w28 = util::SafeLoadAs<uint64_t>(in);
-  w28 = arrow::BitUtil::FromLittleEndian(w28);
+  w28 = arrow::bit_util::FromLittleEndian(w28);
   in += 8;
   uint64_t w29 = util::SafeLoadAs<uint64_t>(in);
-  w29 = arrow::BitUtil::FromLittleEndian(w29);
+  w29 = arrow::bit_util::FromLittleEndian(w29);
   in += 8;
   uint64_t w30 = util::SafeLoadAs<uint64_t>(in);
-  w30 = arrow::BitUtil::FromLittleEndian(w30);
+  w30 = arrow::bit_util::FromLittleEndian(w30);
   in += 8;
   uint64_t w31 = util::SafeLoadAs<uint64_t>(in);
-  w31 = arrow::BitUtil::FromLittleEndian(w31);
+  w31 = arrow::bit_util::FromLittleEndian(w31);
   in += 8;
   out[0] = w0;
   out[1] = w1;
diff --git a/cpp/src/arrow/util/bpacking_default.h b/cpp/src/arrow/util/bpacking_default.h
index d2516effa4d..4c661dcce37 100644
--- a/cpp/src/arrow/util/bpacking_default.h
+++ b/cpp/src/arrow/util/bpacking_default.h
@@ -34,7 +34,7 @@ namespace internal {
 
 inline const uint32_t* unpack1_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) & 1;
   out++;
   *out = (inl >> 1) & 1;
@@ -106,7 +106,7 @@ inline const uint32_t* unpack1_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack2_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 2);
   out++;
   *out = (inl >> 2) % (1U << 2);
@@ -140,7 +140,7 @@ inline const uint32_t* unpack2_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 2);
   out++;
@@ -181,7 +181,7 @@ inline const uint32_t* unpack2_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack3_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 3);
   out++;
   *out = (inl >> 3) % (1U << 3);
@@ -205,7 +205,7 @@ inline const uint32_t* unpack3_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 1)) << (3 - 1);
   out++;
   *out = (inl >> 1) % (1U << 3);
@@ -231,7 +231,7 @@ inline const uint32_t* unpack3_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 31);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (3 - 2);
   out++;
   *out = (inl >> 2) % (1U << 3);
@@ -261,7 +261,7 @@ inline const uint32_t* unpack3_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack4_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 4);
   out++;
   *out = (inl >> 4) % (1U << 4);
@@ -279,7 +279,7 @@ inline const uint32_t* unpack4_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 4);
   out++;
@@ -298,7 +298,7 @@ inline const uint32_t* unpack4_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 4);
   out++;
@@ -317,7 +317,7 @@ inline const uint32_t* unpack4_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 4);
   out++;
@@ -342,7 +342,7 @@ inline const uint32_t* unpack4_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack5_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 5);
   out++;
   *out = (inl >> 5) % (1U << 5);
@@ -358,7 +358,7 @@ inline const uint32_t* unpack5_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 3)) << (5 - 3);
   out++;
   *out = (inl >> 3) % (1U << 5);
@@ -374,7 +374,7 @@ inline const uint32_t* unpack5_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 1)) << (5 - 1);
   out++;
   *out = (inl >> 1) % (1U << 5);
@@ -392,7 +392,7 @@ inline const uint32_t* unpack5_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 31);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (5 - 4);
   out++;
   *out = (inl >> 4) % (1U << 5);
@@ -408,7 +408,7 @@ inline const uint32_t* unpack5_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 29);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (5 - 2);
   out++;
   *out = (inl >> 2) % (1U << 5);
@@ -430,7 +430,7 @@ inline const uint32_t* unpack5_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack6_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 6);
   out++;
   *out = (inl >> 6) % (1U << 6);
@@ -444,7 +444,7 @@ inline const uint32_t* unpack6_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (6 - 4);
   out++;
   *out = (inl >> 4) % (1U << 6);
@@ -458,7 +458,7 @@ inline const uint32_t* unpack6_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (6 - 2);
   out++;
   *out = (inl >> 2) % (1U << 6);
@@ -472,7 +472,7 @@ inline const uint32_t* unpack6_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 6);
   out++;
@@ -487,7 +487,7 @@ inline const uint32_t* unpack6_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (6 - 4);
   out++;
   *out = (inl >> 4) % (1U << 6);
@@ -501,7 +501,7 @@ inline const uint32_t* unpack6_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (6 - 2);
   out++;
   *out = (inl >> 2) % (1U << 6);
@@ -521,7 +521,7 @@ inline const uint32_t* unpack6_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack7_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 7);
   out++;
   *out = (inl >> 7) % (1U << 7);
@@ -533,7 +533,7 @@ inline const uint32_t* unpack7_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 3)) << (7 - 3);
   out++;
   *out = (inl >> 3) % (1U << 7);
@@ -547,7 +547,7 @@ inline const uint32_t* unpack7_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 31);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (7 - 6);
   out++;
   *out = (inl >> 6) % (1U << 7);
@@ -559,7 +559,7 @@ inline const uint32_t* unpack7_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 27);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (7 - 2);
   out++;
   *out = (inl >> 2) % (1U << 7);
@@ -573,7 +573,7 @@ inline const uint32_t* unpack7_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 5)) << (7 - 5);
   out++;
   *out = (inl >> 5) % (1U << 7);
@@ -585,7 +585,7 @@ inline const uint32_t* unpack7_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 1)) << (7 - 1);
   out++;
   *out = (inl >> 1) % (1U << 7);
@@ -599,7 +599,7 @@ inline const uint32_t* unpack7_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 29);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (7 - 4);
   out++;
   *out = (inl >> 4) % (1U << 7);
@@ -617,7 +617,7 @@ inline const uint32_t* unpack7_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack8_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 8);
   out++;
   *out = (inl >> 8) % (1U << 8);
@@ -627,7 +627,7 @@ inline const uint32_t* unpack8_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 8);
   out++;
@@ -638,7 +638,7 @@ inline const uint32_t* unpack8_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 8);
   out++;
@@ -649,7 +649,7 @@ inline const uint32_t* unpack8_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 8);
   out++;
@@ -660,7 +660,7 @@ inline const uint32_t* unpack8_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 8);
   out++;
@@ -671,7 +671,7 @@ inline const uint32_t* unpack8_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 8);
   out++;
@@ -682,7 +682,7 @@ inline const uint32_t* unpack8_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 8);
   out++;
@@ -693,7 +693,7 @@ inline const uint32_t* unpack8_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 8);
   out++;
@@ -710,7 +710,7 @@ inline const uint32_t* unpack8_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack9_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 9);
   out++;
   *out = (inl >> 9) % (1U << 9);
@@ -720,7 +720,7 @@ inline const uint32_t* unpack9_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 27);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (9 - 4);
   out++;
   *out = (inl >> 4) % (1U << 9);
@@ -732,7 +732,7 @@ inline const uint32_t* unpack9_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 31);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (9 - 8);
   out++;
   *out = (inl >> 8) % (1U << 9);
@@ -742,7 +742,7 @@ inline const uint32_t* unpack9_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 3)) << (9 - 3);
   out++;
   *out = (inl >> 3) % (1U << 9);
@@ -754,7 +754,7 @@ inline const uint32_t* unpack9_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 7)) << (9 - 7);
   out++;
   *out = (inl >> 7) % (1U << 9);
@@ -764,7 +764,7 @@ inline const uint32_t* unpack9_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 25);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (9 - 2);
   out++;
   *out = (inl >> 2) % (1U << 9);
@@ -776,7 +776,7 @@ inline const uint32_t* unpack9_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 29);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (9 - 6);
   out++;
   *out = (inl >> 6) % (1U << 9);
@@ -786,7 +786,7 @@ inline const uint32_t* unpack9_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 1)) << (9 - 1);
   out++;
   *out = (inl >> 1) % (1U << 9);
@@ -798,7 +798,7 @@ inline const uint32_t* unpack9_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 5)) << (9 - 5);
   out++;
   *out = (inl >> 5) % (1U << 9);
@@ -814,7 +814,7 @@ inline const uint32_t* unpack9_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack10_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 10);
   out++;
   *out = (inl >> 10) % (1U << 10);
@@ -824,7 +824,7 @@ inline const uint32_t* unpack10_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (10 - 8);
   out++;
   *out = (inl >> 8) % (1U << 10);
@@ -834,7 +834,7 @@ inline const uint32_t* unpack10_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (10 - 6);
   out++;
   *out = (inl >> 6) % (1U << 10);
@@ -844,7 +844,7 @@ inline const uint32_t* unpack10_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (10 - 4);
   out++;
   *out = (inl >> 4) % (1U << 10);
@@ -854,7 +854,7 @@ inline const uint32_t* unpack10_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (10 - 2);
   out++;
   *out = (inl >> 2) % (1U << 10);
@@ -864,7 +864,7 @@ inline const uint32_t* unpack10_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 10);
   out++;
@@ -875,7 +875,7 @@ inline const uint32_t* unpack10_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (10 - 8);
   out++;
   *out = (inl >> 8) % (1U << 10);
@@ -885,7 +885,7 @@ inline const uint32_t* unpack10_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (10 - 6);
   out++;
   *out = (inl >> 6) % (1U << 10);
@@ -895,7 +895,7 @@ inline const uint32_t* unpack10_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (10 - 4);
   out++;
   *out = (inl >> 4) % (1U << 10);
@@ -905,7 +905,7 @@ inline const uint32_t* unpack10_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (10 - 2);
   out++;
   *out = (inl >> 2) % (1U << 10);
@@ -921,7 +921,7 @@ inline const uint32_t* unpack10_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack11_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 11);
   out++;
   *out = (inl >> 11) % (1U << 11);
@@ -929,7 +929,7 @@ inline const uint32_t* unpack11_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 1)) << (11 - 1);
   out++;
   *out = (inl >> 1) % (1U << 11);
@@ -939,7 +939,7 @@ inline const uint32_t* unpack11_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 23);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (11 - 2);
   out++;
   *out = (inl >> 2) % (1U << 11);
@@ -949,7 +949,7 @@ inline const uint32_t* unpack11_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 3)) << (11 - 3);
   out++;
   *out = (inl >> 3) % (1U << 11);
@@ -959,7 +959,7 @@ inline const uint32_t* unpack11_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 25);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (11 - 4);
   out++;
   *out = (inl >> 4) % (1U << 11);
@@ -969,7 +969,7 @@ inline const uint32_t* unpack11_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 5)) << (11 - 5);
   out++;
   *out = (inl >> 5) % (1U << 11);
@@ -979,7 +979,7 @@ inline const uint32_t* unpack11_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 27);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (11 - 6);
   out++;
   *out = (inl >> 6) % (1U << 11);
@@ -989,7 +989,7 @@ inline const uint32_t* unpack11_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 7)) << (11 - 7);
   out++;
   *out = (inl >> 7) % (1U << 11);
@@ -999,7 +999,7 @@ inline const uint32_t* unpack11_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 29);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (11 - 8);
   out++;
   *out = (inl >> 8) % (1U << 11);
@@ -1009,7 +1009,7 @@ inline const uint32_t* unpack11_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 9)) << (11 - 9);
   out++;
   *out = (inl >> 9) % (1U << 11);
@@ -1019,7 +1019,7 @@ inline const uint32_t* unpack11_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 31);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (11 - 10);
   out++;
   *out = (inl >> 10) % (1U << 11);
@@ -1033,7 +1033,7 @@ inline const uint32_t* unpack11_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack12_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 12);
   out++;
   *out = (inl >> 12) % (1U << 12);
@@ -1041,7 +1041,7 @@ inline const uint32_t* unpack12_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (12 - 4);
   out++;
   *out = (inl >> 4) % (1U << 12);
@@ -1051,7 +1051,7 @@ inline const uint32_t* unpack12_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (12 - 8);
   out++;
   *out = (inl >> 8) % (1U << 12);
@@ -1059,7 +1059,7 @@ inline const uint32_t* unpack12_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 12);
   out++;
@@ -1068,7 +1068,7 @@ inline const uint32_t* unpack12_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (12 - 4);
   out++;
   *out = (inl >> 4) % (1U << 12);
@@ -1078,7 +1078,7 @@ inline const uint32_t* unpack12_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (12 - 8);
   out++;
   *out = (inl >> 8) % (1U << 12);
@@ -1086,7 +1086,7 @@ inline const uint32_t* unpack12_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 12);
   out++;
@@ -1095,7 +1095,7 @@ inline const uint32_t* unpack12_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (12 - 4);
   out++;
   *out = (inl >> 4) % (1U << 12);
@@ -1105,7 +1105,7 @@ inline const uint32_t* unpack12_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (12 - 8);
   out++;
   *out = (inl >> 8) % (1U << 12);
@@ -1113,7 +1113,7 @@ inline const uint32_t* unpack12_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 12);
   out++;
@@ -1122,7 +1122,7 @@ inline const uint32_t* unpack12_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (12 - 4);
   out++;
   *out = (inl >> 4) % (1U << 12);
@@ -1132,7 +1132,7 @@ inline const uint32_t* unpack12_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (12 - 8);
   out++;
   *out = (inl >> 8) % (1U << 12);
@@ -1146,7 +1146,7 @@ inline const uint32_t* unpack12_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack13_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 13);
   out++;
   *out = (inl >> 13) % (1U << 13);
@@ -1154,7 +1154,7 @@ inline const uint32_t* unpack13_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 7)) << (13 - 7);
   out++;
   *out = (inl >> 7) % (1U << 13);
@@ -1162,7 +1162,7 @@ inline const uint32_t* unpack13_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 1)) << (13 - 1);
   out++;
   *out = (inl >> 1) % (1U << 13);
@@ -1172,7 +1172,7 @@ inline const uint32_t* unpack13_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 27);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (13 - 8);
   out++;
   *out = (inl >> 8) % (1U << 13);
@@ -1180,7 +1180,7 @@ inline const uint32_t* unpack13_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 21);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (13 - 2);
   out++;
   *out = (inl >> 2) % (1U << 13);
@@ -1190,7 +1190,7 @@ inline const uint32_t* unpack13_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 9)) << (13 - 9);
   out++;
   *out = (inl >> 9) % (1U << 13);
@@ -1198,7 +1198,7 @@ inline const uint32_t* unpack13_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 3)) << (13 - 3);
   out++;
   *out = (inl >> 3) % (1U << 13);
@@ -1208,7 +1208,7 @@ inline const uint32_t* unpack13_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 29);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (13 - 10);
   out++;
   *out = (inl >> 10) % (1U << 13);
@@ -1216,7 +1216,7 @@ inline const uint32_t* unpack13_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 23);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (13 - 4);
   out++;
   *out = (inl >> 4) % (1U << 13);
@@ -1226,7 +1226,7 @@ inline const uint32_t* unpack13_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 11)) << (13 - 11);
   out++;
   *out = (inl >> 11) % (1U << 13);
@@ -1234,7 +1234,7 @@ inline const uint32_t* unpack13_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 5)) << (13 - 5);
   out++;
   *out = (inl >> 5) % (1U << 13);
@@ -1244,7 +1244,7 @@ inline const uint32_t* unpack13_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 31);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (13 - 12);
   out++;
   *out = (inl >> 12) % (1U << 13);
@@ -1252,7 +1252,7 @@ inline const uint32_t* unpack13_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 25);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (13 - 6);
   out++;
   *out = (inl >> 6) % (1U << 13);
@@ -1266,7 +1266,7 @@ inline const uint32_t* unpack13_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack14_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 14);
   out++;
   *out = (inl >> 14) % (1U << 14);
@@ -1274,7 +1274,7 @@ inline const uint32_t* unpack14_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (14 - 10);
   out++;
   *out = (inl >> 10) % (1U << 14);
@@ -1282,7 +1282,7 @@ inline const uint32_t* unpack14_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (14 - 6);
   out++;
   *out = (inl >> 6) % (1U << 14);
@@ -1290,7 +1290,7 @@ inline const uint32_t* unpack14_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (14 - 2);
   out++;
   *out = (inl >> 2) % (1U << 14);
@@ -1300,7 +1300,7 @@ inline const uint32_t* unpack14_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (14 - 12);
   out++;
   *out = (inl >> 12) % (1U << 14);
@@ -1308,7 +1308,7 @@ inline const uint32_t* unpack14_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (14 - 8);
   out++;
   *out = (inl >> 8) % (1U << 14);
@@ -1316,7 +1316,7 @@ inline const uint32_t* unpack14_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (14 - 4);
   out++;
   *out = (inl >> 4) % (1U << 14);
@@ -1324,7 +1324,7 @@ inline const uint32_t* unpack14_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 18);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 14);
   out++;
@@ -1333,7 +1333,7 @@ inline const uint32_t* unpack14_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (14 - 10);
   out++;
   *out = (inl >> 10) % (1U << 14);
@@ -1341,7 +1341,7 @@ inline const uint32_t* unpack14_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (14 - 6);
   out++;
   *out = (inl >> 6) % (1U << 14);
@@ -1349,7 +1349,7 @@ inline const uint32_t* unpack14_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (14 - 2);
   out++;
   *out = (inl >> 2) % (1U << 14);
@@ -1359,7 +1359,7 @@ inline const uint32_t* unpack14_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (14 - 12);
   out++;
   *out = (inl >> 12) % (1U << 14);
@@ -1367,7 +1367,7 @@ inline const uint32_t* unpack14_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (14 - 8);
   out++;
   *out = (inl >> 8) % (1U << 14);
@@ -1375,7 +1375,7 @@ inline const uint32_t* unpack14_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (14 - 4);
   out++;
   *out = (inl >> 4) % (1U << 14);
@@ -1389,7 +1389,7 @@ inline const uint32_t* unpack14_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack15_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 15);
   out++;
   *out = (inl >> 15) % (1U << 15);
@@ -1397,7 +1397,7 @@ inline const uint32_t* unpack15_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 13)) << (15 - 13);
   out++;
   *out = (inl >> 13) % (1U << 15);
@@ -1405,7 +1405,7 @@ inline const uint32_t* unpack15_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 11)) << (15 - 11);
   out++;
   *out = (inl >> 11) % (1U << 15);
@@ -1413,7 +1413,7 @@ inline const uint32_t* unpack15_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 9)) << (15 - 9);
   out++;
   *out = (inl >> 9) % (1U << 15);
@@ -1421,7 +1421,7 @@ inline const uint32_t* unpack15_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 7)) << (15 - 7);
   out++;
   *out = (inl >> 7) % (1U << 15);
@@ -1429,7 +1429,7 @@ inline const uint32_t* unpack15_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 5)) << (15 - 5);
   out++;
   *out = (inl >> 5) % (1U << 15);
@@ -1437,7 +1437,7 @@ inline const uint32_t* unpack15_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 3)) << (15 - 3);
   out++;
   *out = (inl >> 3) % (1U << 15);
@@ -1445,7 +1445,7 @@ inline const uint32_t* unpack15_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 18);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 1)) << (15 - 1);
   out++;
   *out = (inl >> 1) % (1U << 15);
@@ -1455,7 +1455,7 @@ inline const uint32_t* unpack15_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 31);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 14)) << (15 - 14);
   out++;
   *out = (inl >> 14) % (1U << 15);
@@ -1463,7 +1463,7 @@ inline const uint32_t* unpack15_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 29);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (15 - 12);
   out++;
   *out = (inl >> 12) % (1U << 15);
@@ -1471,7 +1471,7 @@ inline const uint32_t* unpack15_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 27);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (15 - 10);
   out++;
   *out = (inl >> 10) % (1U << 15);
@@ -1479,7 +1479,7 @@ inline const uint32_t* unpack15_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 25);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (15 - 8);
   out++;
   *out = (inl >> 8) % (1U << 15);
@@ -1487,7 +1487,7 @@ inline const uint32_t* unpack15_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 23);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (15 - 6);
   out++;
   *out = (inl >> 6) % (1U << 15);
@@ -1495,7 +1495,7 @@ inline const uint32_t* unpack15_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 21);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (15 - 4);
   out++;
   *out = (inl >> 4) % (1U << 15);
@@ -1503,7 +1503,7 @@ inline const uint32_t* unpack15_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 19);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (15 - 2);
   out++;
   *out = (inl >> 2) % (1U << 15);
@@ -1517,111 +1517,111 @@ inline const uint32_t* unpack15_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack16_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 16);
   out++;
@@ -1634,13 +1634,13 @@ inline const uint32_t* unpack16_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack17_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 17);
   out++;
   *out = (inl >> 17);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (17 - 2);
   out++;
   *out = (inl >> 2) % (1U << 17);
@@ -1648,7 +1648,7 @@ inline const uint32_t* unpack17_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 19);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (17 - 4);
   out++;
   *out = (inl >> 4) % (1U << 17);
@@ -1656,7 +1656,7 @@ inline const uint32_t* unpack17_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 21);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (17 - 6);
   out++;
   *out = (inl >> 6) % (1U << 17);
@@ -1664,7 +1664,7 @@ inline const uint32_t* unpack17_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 23);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (17 - 8);
   out++;
   *out = (inl >> 8) % (1U << 17);
@@ -1672,7 +1672,7 @@ inline const uint32_t* unpack17_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 25);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (17 - 10);
   out++;
   *out = (inl >> 10) % (1U << 17);
@@ -1680,7 +1680,7 @@ inline const uint32_t* unpack17_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 27);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (17 - 12);
   out++;
   *out = (inl >> 12) % (1U << 17);
@@ -1688,7 +1688,7 @@ inline const uint32_t* unpack17_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 29);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 14)) << (17 - 14);
   out++;
   *out = (inl >> 14) % (1U << 17);
@@ -1696,13 +1696,13 @@ inline const uint32_t* unpack17_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 31);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (17 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 1)) << (17 - 1);
   out++;
   *out = (inl >> 1) % (1U << 17);
@@ -1710,7 +1710,7 @@ inline const uint32_t* unpack17_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 18);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 3)) << (17 - 3);
   out++;
   *out = (inl >> 3) % (1U << 17);
@@ -1718,7 +1718,7 @@ inline const uint32_t* unpack17_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 5)) << (17 - 5);
   out++;
   *out = (inl >> 5) % (1U << 17);
@@ -1726,7 +1726,7 @@ inline const uint32_t* unpack17_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 7)) << (17 - 7);
   out++;
   *out = (inl >> 7) % (1U << 17);
@@ -1734,7 +1734,7 @@ inline const uint32_t* unpack17_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 9)) << (17 - 9);
   out++;
   *out = (inl >> 9) % (1U << 17);
@@ -1742,7 +1742,7 @@ inline const uint32_t* unpack17_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 11)) << (17 - 11);
   out++;
   *out = (inl >> 11) % (1U << 17);
@@ -1750,7 +1750,7 @@ inline const uint32_t* unpack17_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 13)) << (17 - 13);
   out++;
   *out = (inl >> 13) % (1U << 17);
@@ -1758,7 +1758,7 @@ inline const uint32_t* unpack17_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 15)) << (17 - 15);
   out++;
   *out = (inl >> 15);
@@ -1770,13 +1770,13 @@ inline const uint32_t* unpack17_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack18_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 18);
   out++;
   *out = (inl >> 18);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (18 - 4);
   out++;
   *out = (inl >> 4) % (1U << 18);
@@ -1784,7 +1784,7 @@ inline const uint32_t* unpack18_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (18 - 8);
   out++;
   *out = (inl >> 8) % (1U << 18);
@@ -1792,7 +1792,7 @@ inline const uint32_t* unpack18_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (18 - 12);
   out++;
   *out = (inl >> 12) % (1U << 18);
@@ -1800,13 +1800,13 @@ inline const uint32_t* unpack18_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (18 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (18 - 2);
   out++;
   *out = (inl >> 2) % (1U << 18);
@@ -1814,7 +1814,7 @@ inline const uint32_t* unpack18_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (18 - 6);
   out++;
   *out = (inl >> 6) % (1U << 18);
@@ -1822,7 +1822,7 @@ inline const uint32_t* unpack18_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (18 - 10);
   out++;
   *out = (inl >> 10) % (1U << 18);
@@ -1830,20 +1830,20 @@ inline const uint32_t* unpack18_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 14)) << (18 - 14);
   out++;
   *out = (inl >> 14);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 18);
   out++;
   *out = (inl >> 18);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (18 - 4);
   out++;
   *out = (inl >> 4) % (1U << 18);
@@ -1851,7 +1851,7 @@ inline const uint32_t* unpack18_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (18 - 8);
   out++;
   *out = (inl >> 8) % (1U << 18);
@@ -1859,7 +1859,7 @@ inline const uint32_t* unpack18_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (18 - 12);
   out++;
   *out = (inl >> 12) % (1U << 18);
@@ -1867,13 +1867,13 @@ inline const uint32_t* unpack18_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (18 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (18 - 2);
   out++;
   *out = (inl >> 2) % (1U << 18);
@@ -1881,7 +1881,7 @@ inline const uint32_t* unpack18_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (18 - 6);
   out++;
   *out = (inl >> 6) % (1U << 18);
@@ -1889,7 +1889,7 @@ inline const uint32_t* unpack18_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (18 - 10);
   out++;
   *out = (inl >> 10) % (1U << 18);
@@ -1897,7 +1897,7 @@ inline const uint32_t* unpack18_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 14)) << (18 - 14);
   out++;
   *out = (inl >> 14);
@@ -1909,13 +1909,13 @@ inline const uint32_t* unpack18_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack19_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 19);
   out++;
   *out = (inl >> 19);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (19 - 6);
   out++;
   *out = (inl >> 6) % (1U << 19);
@@ -1923,7 +1923,7 @@ inline const uint32_t* unpack19_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 25);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (19 - 12);
   out++;
   *out = (inl >> 12) % (1U << 19);
@@ -1931,13 +1931,13 @@ inline const uint32_t* unpack19_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 31);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 18)) << (19 - 18);
   out++;
   *out = (inl >> 18);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 5)) << (19 - 5);
   out++;
   *out = (inl >> 5) % (1U << 19);
@@ -1945,7 +1945,7 @@ inline const uint32_t* unpack19_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 11)) << (19 - 11);
   out++;
   *out = (inl >> 11) % (1U << 19);
@@ -1953,13 +1953,13 @@ inline const uint32_t* unpack19_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 17)) << (19 - 17);
   out++;
   *out = (inl >> 17);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (19 - 4);
   out++;
   *out = (inl >> 4) % (1U << 19);
@@ -1967,7 +1967,7 @@ inline const uint32_t* unpack19_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 23);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (19 - 10);
   out++;
   *out = (inl >> 10) % (1U << 19);
@@ -1975,13 +1975,13 @@ inline const uint32_t* unpack19_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 29);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (19 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 3)) << (19 - 3);
   out++;
   *out = (inl >> 3) % (1U << 19);
@@ -1989,7 +1989,7 @@ inline const uint32_t* unpack19_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 9)) << (19 - 9);
   out++;
   *out = (inl >> 9) % (1U << 19);
@@ -1997,13 +1997,13 @@ inline const uint32_t* unpack19_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 15)) << (19 - 15);
   out++;
   *out = (inl >> 15);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (19 - 2);
   out++;
   *out = (inl >> 2) % (1U << 19);
@@ -2011,7 +2011,7 @@ inline const uint32_t* unpack19_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 21);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (19 - 8);
   out++;
   *out = (inl >> 8) % (1U << 19);
@@ -2019,13 +2019,13 @@ inline const uint32_t* unpack19_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 27);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 14)) << (19 - 14);
   out++;
   *out = (inl >> 14);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 1)) << (19 - 1);
   out++;
   *out = (inl >> 1) % (1U << 19);
@@ -2033,7 +2033,7 @@ inline const uint32_t* unpack19_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 7)) << (19 - 7);
   out++;
   *out = (inl >> 7) % (1U << 19);
@@ -2041,7 +2041,7 @@ inline const uint32_t* unpack19_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 13)) << (19 - 13);
   out++;
   *out = (inl >> 13);
@@ -2053,13 +2053,13 @@ inline const uint32_t* unpack19_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack20_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (20 - 8);
   out++;
   *out = (inl >> 8) % (1U << 20);
@@ -2067,13 +2067,13 @@ inline const uint32_t* unpack20_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (20 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (20 - 4);
   out++;
   *out = (inl >> 4) % (1U << 20);
@@ -2081,20 +2081,20 @@ inline const uint32_t* unpack20_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (20 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (20 - 8);
   out++;
   *out = (inl >> 8) % (1U << 20);
@@ -2102,13 +2102,13 @@ inline const uint32_t* unpack20_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (20 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (20 - 4);
   out++;
   *out = (inl >> 4) % (1U << 20);
@@ -2116,20 +2116,20 @@ inline const uint32_t* unpack20_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (20 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (20 - 8);
   out++;
   *out = (inl >> 8) % (1U << 20);
@@ -2137,13 +2137,13 @@ inline const uint32_t* unpack20_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (20 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (20 - 4);
   out++;
   *out = (inl >> 4) % (1U << 20);
@@ -2151,20 +2151,20 @@ inline const uint32_t* unpack20_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (20 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (20 - 8);
   out++;
   *out = (inl >> 8) % (1U << 20);
@@ -2172,13 +2172,13 @@ inline const uint32_t* unpack20_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (20 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (20 - 4);
   out++;
   *out = (inl >> 4) % (1U << 20);
@@ -2186,7 +2186,7 @@ inline const uint32_t* unpack20_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (20 - 12);
   out++;
   *out = (inl >> 12);
@@ -2198,13 +2198,13 @@ inline const uint32_t* unpack20_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack21_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 21);
   out++;
   *out = (inl >> 21);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (21 - 10);
   out++;
   *out = (inl >> 10) % (1U << 21);
@@ -2212,13 +2212,13 @@ inline const uint32_t* unpack21_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 31);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 20)) << (21 - 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 9)) << (21 - 9);
   out++;
   *out = (inl >> 9) % (1U << 21);
@@ -2226,13 +2226,13 @@ inline const uint32_t* unpack21_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 19)) << (21 - 19);
   out++;
   *out = (inl >> 19);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (21 - 8);
   out++;
   *out = (inl >> 8) % (1U << 21);
@@ -2240,13 +2240,13 @@ inline const uint32_t* unpack21_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 29);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 18)) << (21 - 18);
   out++;
   *out = (inl >> 18);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 7)) << (21 - 7);
   out++;
   *out = (inl >> 7) % (1U << 21);
@@ -2254,13 +2254,13 @@ inline const uint32_t* unpack21_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 17)) << (21 - 17);
   out++;
   *out = (inl >> 17);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (21 - 6);
   out++;
   *out = (inl >> 6) % (1U << 21);
@@ -2268,13 +2268,13 @@ inline const uint32_t* unpack21_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 27);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (21 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 5)) << (21 - 5);
   out++;
   *out = (inl >> 5) % (1U << 21);
@@ -2282,13 +2282,13 @@ inline const uint32_t* unpack21_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 15)) << (21 - 15);
   out++;
   *out = (inl >> 15);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (21 - 4);
   out++;
   *out = (inl >> 4) % (1U << 21);
@@ -2296,13 +2296,13 @@ inline const uint32_t* unpack21_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 25);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 14)) << (21 - 14);
   out++;
   *out = (inl >> 14);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 3)) << (21 - 3);
   out++;
   *out = (inl >> 3) % (1U << 21);
@@ -2310,13 +2310,13 @@ inline const uint32_t* unpack21_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 13)) << (21 - 13);
   out++;
   *out = (inl >> 13);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (21 - 2);
   out++;
   *out = (inl >> 2) % (1U << 21);
@@ -2324,13 +2324,13 @@ inline const uint32_t* unpack21_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 23);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (21 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 1)) << (21 - 1);
   out++;
   *out = (inl >> 1) % (1U << 21);
@@ -2338,7 +2338,7 @@ inline const uint32_t* unpack21_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 11)) << (21 - 11);
   out++;
   *out = (inl >> 11);
@@ -2350,19 +2350,19 @@ inline const uint32_t* unpack21_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack22_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 22);
   out++;
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (22 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (22 - 2);
   out++;
   *out = (inl >> 2) % (1U << 22);
@@ -2370,13 +2370,13 @@ inline const uint32_t* unpack22_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 14)) << (22 - 14);
   out++;
   *out = (inl >> 14);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (22 - 4);
   out++;
   *out = (inl >> 4) % (1U << 22);
@@ -2384,13 +2384,13 @@ inline const uint32_t* unpack22_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (22 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (22 - 6);
   out++;
   *out = (inl >> 6) % (1U << 22);
@@ -2398,13 +2398,13 @@ inline const uint32_t* unpack22_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 18)) << (22 - 18);
   out++;
   *out = (inl >> 18);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (22 - 8);
   out++;
   *out = (inl >> 8) % (1U << 22);
@@ -2412,32 +2412,32 @@ inline const uint32_t* unpack22_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 20)) << (22 - 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (22 - 10);
   out++;
   *out = (inl >> 10);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 22);
   out++;
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (22 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (22 - 2);
   out++;
   *out = (inl >> 2) % (1U << 22);
@@ -2445,13 +2445,13 @@ inline const uint32_t* unpack22_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 14)) << (22 - 14);
   out++;
   *out = (inl >> 14);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (22 - 4);
   out++;
   *out = (inl >> 4) % (1U << 22);
@@ -2459,13 +2459,13 @@ inline const uint32_t* unpack22_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (22 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (22 - 6);
   out++;
   *out = (inl >> 6) % (1U << 22);
@@ -2473,13 +2473,13 @@ inline const uint32_t* unpack22_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 18)) << (22 - 18);
   out++;
   *out = (inl >> 18);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (22 - 8);
   out++;
   *out = (inl >> 8) % (1U << 22);
@@ -2487,13 +2487,13 @@ inline const uint32_t* unpack22_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 20)) << (22 - 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (22 - 10);
   out++;
   *out = (inl >> 10);
@@ -2505,19 +2505,19 @@ inline const uint32_t* unpack22_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack23_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 23);
   out++;
   *out = (inl >> 23);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 14)) << (23 - 14);
   out++;
   *out = (inl >> 14);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 5)) << (23 - 5);
   out++;
   *out = (inl >> 5) % (1U << 23);
@@ -2525,19 +2525,19 @@ inline const uint32_t* unpack23_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 19)) << (23 - 19);
   out++;
   *out = (inl >> 19);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (23 - 10);
   out++;
   *out = (inl >> 10);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 1)) << (23 - 1);
   out++;
   *out = (inl >> 1) % (1U << 23);
@@ -2545,13 +2545,13 @@ inline const uint32_t* unpack23_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 15)) << (23 - 15);
   out++;
   *out = (inl >> 15);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (23 - 6);
   out++;
   *out = (inl >> 6) % (1U << 23);
@@ -2559,19 +2559,19 @@ inline const uint32_t* unpack23_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 29);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 20)) << (23 - 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 11)) << (23 - 11);
   out++;
   *out = (inl >> 11);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (23 - 2);
   out++;
   *out = (inl >> 2) % (1U << 23);
@@ -2579,13 +2579,13 @@ inline const uint32_t* unpack23_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 25);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (23 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 7)) << (23 - 7);
   out++;
   *out = (inl >> 7) % (1U << 23);
@@ -2593,19 +2593,19 @@ inline const uint32_t* unpack23_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 21)) << (23 - 21);
   out++;
   *out = (inl >> 21);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (23 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 3)) << (23 - 3);
   out++;
   *out = (inl >> 3) % (1U << 23);
@@ -2613,13 +2613,13 @@ inline const uint32_t* unpack23_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 17)) << (23 - 17);
   out++;
   *out = (inl >> 17);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (23 - 8);
   out++;
   *out = (inl >> 8) % (1U << 23);
@@ -2627,19 +2627,19 @@ inline const uint32_t* unpack23_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 31);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 22)) << (23 - 22);
   out++;
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 13)) << (23 - 13);
   out++;
   *out = (inl >> 13);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (23 - 4);
   out++;
   *out = (inl >> 4) % (1U << 23);
@@ -2647,13 +2647,13 @@ inline const uint32_t* unpack23_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 27);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 18)) << (23 - 18);
   out++;
   *out = (inl >> 18);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 9)) << (23 - 9);
   out++;
   *out = (inl >> 9);
@@ -2665,152 +2665,152 @@ inline const uint32_t* unpack23_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack24_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (24 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (24 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (24 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (24 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (24 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (24 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (24 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (24 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (24 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (24 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (24 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (24 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (24 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (24 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (24 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (24 - 8);
   out++;
   *out = (inl >> 8);
@@ -2822,25 +2822,25 @@ inline const uint32_t* unpack24_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack25_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 25);
   out++;
   *out = (inl >> 25);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 18)) << (25 - 18);
   out++;
   *out = (inl >> 18);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 11)) << (25 - 11);
   out++;
   *out = (inl >> 11);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (25 - 4);
   out++;
   *out = (inl >> 4) % (1U << 25);
@@ -2848,25 +2848,25 @@ inline const uint32_t* unpack25_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 29);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 22)) << (25 - 22);
   out++;
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 15)) << (25 - 15);
   out++;
   *out = (inl >> 15);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (25 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 1)) << (25 - 1);
   out++;
   *out = (inl >> 1) % (1U << 25);
@@ -2874,19 +2874,19 @@ inline const uint32_t* unpack25_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 19)) << (25 - 19);
   out++;
   *out = (inl >> 19);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (25 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 5)) << (25 - 5);
   out++;
   *out = (inl >> 5) % (1U << 25);
@@ -2894,25 +2894,25 @@ inline const uint32_t* unpack25_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 23)) << (25 - 23);
   out++;
   *out = (inl >> 23);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (25 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 9)) << (25 - 9);
   out++;
   *out = (inl >> 9);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (25 - 2);
   out++;
   *out = (inl >> 2) % (1U << 25);
@@ -2920,19 +2920,19 @@ inline const uint32_t* unpack25_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 27);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 20)) << (25 - 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 13)) << (25 - 13);
   out++;
   *out = (inl >> 13);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (25 - 6);
   out++;
   *out = (inl >> 6) % (1U << 25);
@@ -2940,25 +2940,25 @@ inline const uint32_t* unpack25_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 31);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 24)) << (25 - 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 17)) << (25 - 17);
   out++;
   *out = (inl >> 17);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (25 - 10);
   out++;
   *out = (inl >> 10);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 3)) << (25 - 3);
   out++;
   *out = (inl >> 3) % (1U << 25);
@@ -2966,19 +2966,19 @@ inline const uint32_t* unpack25_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 21)) << (25 - 21);
   out++;
   *out = (inl >> 21);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 14)) << (25 - 14);
   out++;
   *out = (inl >> 14);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 7)) << (25 - 7);
   out++;
   *out = (inl >> 7);
@@ -2990,31 +2990,31 @@ inline const uint32_t* unpack25_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack26_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 26);
   out++;
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 20)) << (26 - 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 14)) << (26 - 14);
   out++;
   *out = (inl >> 14);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (26 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (26 - 2);
   out++;
   *out = (inl >> 2) % (1U << 26);
@@ -3022,25 +3022,25 @@ inline const uint32_t* unpack26_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 22)) << (26 - 22);
   out++;
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (26 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (26 - 10);
   out++;
   *out = (inl >> 10);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (26 - 4);
   out++;
   *out = (inl >> 4) % (1U << 26);
@@ -3048,56 +3048,56 @@ inline const uint32_t* unpack26_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 24)) << (26 - 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 18)) << (26 - 18);
   out++;
   *out = (inl >> 18);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (26 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (26 - 6);
   out++;
   *out = (inl >> 6);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 26);
   out++;
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 20)) << (26 - 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 14)) << (26 - 14);
   out++;
   *out = (inl >> 14);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (26 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (26 - 2);
   out++;
   *out = (inl >> 2) % (1U << 26);
@@ -3105,25 +3105,25 @@ inline const uint32_t* unpack26_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 22)) << (26 - 22);
   out++;
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (26 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (26 - 10);
   out++;
   *out = (inl >> 10);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (26 - 4);
   out++;
   *out = (inl >> 4) % (1U << 26);
@@ -3131,25 +3131,25 @@ inline const uint32_t* unpack26_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 24)) << (26 - 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 18)) << (26 - 18);
   out++;
   *out = (inl >> 18);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (26 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (26 - 6);
   out++;
   *out = (inl >> 6);
@@ -3161,37 +3161,37 @@ inline const uint32_t* unpack26_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack27_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 27);
   out++;
   *out = (inl >> 27);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 22)) << (27 - 22);
   out++;
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 17)) << (27 - 17);
   out++;
   *out = (inl >> 17);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (27 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 7)) << (27 - 7);
   out++;
   *out = (inl >> 7);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (27 - 2);
   out++;
   *out = (inl >> 2) % (1U << 27);
@@ -3199,31 +3199,31 @@ inline const uint32_t* unpack27_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 29);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 24)) << (27 - 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 19)) << (27 - 19);
   out++;
   *out = (inl >> 19);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 14)) << (27 - 14);
   out++;
   *out = (inl >> 14);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 9)) << (27 - 9);
   out++;
   *out = (inl >> 9);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (27 - 4);
   out++;
   *out = (inl >> 4) % (1U << 27);
@@ -3231,37 +3231,37 @@ inline const uint32_t* unpack27_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 31);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 26)) << (27 - 26);
   out++;
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 21)) << (27 - 21);
   out++;
   *out = (inl >> 21);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (27 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 11)) << (27 - 11);
   out++;
   *out = (inl >> 11);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (27 - 6);
   out++;
   *out = (inl >> 6);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 1)) << (27 - 1);
   out++;
   *out = (inl >> 1) % (1U << 27);
@@ -3269,31 +3269,31 @@ inline const uint32_t* unpack27_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 23)) << (27 - 23);
   out++;
   *out = (inl >> 23);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 18)) << (27 - 18);
   out++;
   *out = (inl >> 18);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 13)) << (27 - 13);
   out++;
   *out = (inl >> 13);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (27 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 3)) << (27 - 3);
   out++;
   *out = (inl >> 3) % (1U << 27);
@@ -3301,31 +3301,31 @@ inline const uint32_t* unpack27_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 25)) << (27 - 25);
   out++;
   *out = (inl >> 25);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 20)) << (27 - 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 15)) << (27 - 15);
   out++;
   *out = (inl >> 15);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (27 - 10);
   out++;
   *out = (inl >> 10);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 5)) << (27 - 5);
   out++;
   *out = (inl >> 5);
@@ -3337,172 +3337,172 @@ inline const uint32_t* unpack27_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack28_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 28);
   out++;
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 24)) << (28 - 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 20)) << (28 - 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (28 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (28 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (28 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (28 - 4);
   out++;
   *out = (inl >> 4);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 28);
   out++;
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 24)) << (28 - 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 20)) << (28 - 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (28 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (28 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (28 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (28 - 4);
   out++;
   *out = (inl >> 4);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 28);
   out++;
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 24)) << (28 - 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 20)) << (28 - 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (28 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (28 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (28 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (28 - 4);
   out++;
   *out = (inl >> 4);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 28);
   out++;
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 24)) << (28 - 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 20)) << (28 - 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (28 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (28 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (28 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (28 - 4);
   out++;
   *out = (inl >> 4);
@@ -3514,61 +3514,61 @@ inline const uint32_t* unpack28_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack29_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 29);
   out++;
   *out = (inl >> 29);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 26)) << (29 - 26);
   out++;
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 23)) << (29 - 23);
   out++;
   *out = (inl >> 23);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 20)) << (29 - 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 17)) << (29 - 17);
   out++;
   *out = (inl >> 17);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 14)) << (29 - 14);
   out++;
   *out = (inl >> 14);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 11)) << (29 - 11);
   out++;
   *out = (inl >> 11);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (29 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 5)) << (29 - 5);
   out++;
   *out = (inl >> 5);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (29 - 2);
   out++;
   *out = (inl >> 2) % (1U << 29);
@@ -3576,61 +3576,61 @@ inline const uint32_t* unpack29_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 31);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 28)) << (29 - 28);
   out++;
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 25)) << (29 - 25);
   out++;
   *out = (inl >> 25);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 22)) << (29 - 22);
   out++;
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 19)) << (29 - 19);
   out++;
   *out = (inl >> 19);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (29 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 13)) << (29 - 13);
   out++;
   *out = (inl >> 13);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (29 - 10);
   out++;
   *out = (inl >> 10);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 7)) << (29 - 7);
   out++;
   *out = (inl >> 7);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (29 - 4);
   out++;
   *out = (inl >> 4);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 1)) << (29 - 1);
   out++;
   *out = (inl >> 1) % (1U << 29);
@@ -3638,55 +3638,55 @@ inline const uint32_t* unpack29_32(const uint32_t* in, uint32_t* out) {
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 27)) << (29 - 27);
   out++;
   *out = (inl >> 27);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 24)) << (29 - 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 21)) << (29 - 21);
   out++;
   *out = (inl >> 21);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 18)) << (29 - 18);
   out++;
   *out = (inl >> 18);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 15)) << (29 - 15);
   out++;
   *out = (inl >> 15);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (29 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 9)) << (29 - 9);
   out++;
   *out = (inl >> 9);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (29 - 6);
   out++;
   *out = (inl >> 6);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 3)) << (29 - 3);
   out++;
   *out = (inl >> 3);
@@ -3698,182 +3698,182 @@ inline const uint32_t* unpack29_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack30_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 30);
   out++;
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 28)) << (30 - 28);
   out++;
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 26)) << (30 - 26);
   out++;
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 24)) << (30 - 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 22)) << (30 - 22);
   out++;
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 20)) << (30 - 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 18)) << (30 - 18);
   out++;
   *out = (inl >> 18);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (30 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 14)) << (30 - 14);
   out++;
   *out = (inl >> 14);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (30 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (30 - 10);
   out++;
   *out = (inl >> 10);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (30 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (30 - 6);
   out++;
   *out = (inl >> 6);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (30 - 4);
   out++;
   *out = (inl >> 4);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (30 - 2);
   out++;
   *out = (inl >> 2);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0) % (1U << 30);
   out++;
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 28)) << (30 - 28);
   out++;
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 26)) << (30 - 26);
   out++;
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 24)) << (30 - 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 22)) << (30 - 22);
   out++;
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 20)) << (30 - 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 18)) << (30 - 18);
   out++;
   *out = (inl >> 18);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (30 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 14)) << (30 - 14);
   out++;
   *out = (inl >> 14);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (30 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (30 - 10);
   out++;
   *out = (inl >> 10);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (30 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (30 - 6);
   out++;
   *out = (inl >> 6);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (30 - 4);
   out++;
   *out = (inl >> 4);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (30 - 2);
   out++;
   *out = (inl >> 2);
@@ -3885,187 +3885,187 @@ inline const uint32_t* unpack30_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack31_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0) % (1U << 31);
   out++;
   *out = (inl >> 31);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 30)) << (31 - 30);
   out++;
   *out = (inl >> 30);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 29)) << (31 - 29);
   out++;
   *out = (inl >> 29);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 28)) << (31 - 28);
   out++;
   *out = (inl >> 28);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 27)) << (31 - 27);
   out++;
   *out = (inl >> 27);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 26)) << (31 - 26);
   out++;
   *out = (inl >> 26);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 25)) << (31 - 25);
   out++;
   *out = (inl >> 25);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 24)) << (31 - 24);
   out++;
   *out = (inl >> 24);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 23)) << (31 - 23);
   out++;
   *out = (inl >> 23);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 22)) << (31 - 22);
   out++;
   *out = (inl >> 22);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 21)) << (31 - 21);
   out++;
   *out = (inl >> 21);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 20)) << (31 - 20);
   out++;
   *out = (inl >> 20);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 19)) << (31 - 19);
   out++;
   *out = (inl >> 19);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 18)) << (31 - 18);
   out++;
   *out = (inl >> 18);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 17)) << (31 - 17);
   out++;
   *out = (inl >> 17);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 16)) << (31 - 16);
   out++;
   *out = (inl >> 16);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 15)) << (31 - 15);
   out++;
   *out = (inl >> 15);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 14)) << (31 - 14);
   out++;
   *out = (inl >> 14);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 13)) << (31 - 13);
   out++;
   *out = (inl >> 13);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 12)) << (31 - 12);
   out++;
   *out = (inl >> 12);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 11)) << (31 - 11);
   out++;
   *out = (inl >> 11);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 10)) << (31 - 10);
   out++;
   *out = (inl >> 10);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 9)) << (31 - 9);
   out++;
   *out = (inl >> 9);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 8)) << (31 - 8);
   out++;
   *out = (inl >> 8);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 7)) << (31 - 7);
   out++;
   *out = (inl >> 7);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 6)) << (31 - 6);
   out++;
   *out = (inl >> 6);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 5)) << (31 - 5);
   out++;
   *out = (inl >> 5);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 4)) << (31 - 4);
   out++;
   *out = (inl >> 4);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 3)) << (31 - 3);
   out++;
   *out = (inl >> 3);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 2)) << (31 - 2);
   out++;
   *out = (inl >> 2);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out |= (inl % (1U << 1)) << (31 - 1);
   out++;
   *out = (inl >> 1);
@@ -4077,161 +4077,161 @@ inline const uint32_t* unpack31_32(const uint32_t* in, uint32_t* out) {
 
 inline const uint32_t* unpack32_32(const uint32_t* in, uint32_t* out) {
   uint32_t inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
   inl = util::SafeLoad(in);
-  inl = arrow::BitUtil::FromLittleEndian(inl);
+  inl = arrow::bit_util::FromLittleEndian(inl);
   out++;
   *out = (inl >> 0);
   ++in;
diff --git a/cpp/src/arrow/util/byte_size.cc b/cpp/src/arrow/util/byte_size.cc
index 091e3848038..1c9d69488d6 100644
--- a/cpp/src/arrow/util/byte_size.cc
+++ b/cpp/src/arrow/util/byte_size.cc
@@ -122,8 +122,8 @@ struct GetByteRangesArray {
     if (buffer) {
       uint64_t data_start = reinterpret_cast<uint64_t>(buffer->data());
       RETURN_NOT_OK(range_starts->Append(data_start));
-      RETURN_NOT_OK(range_offsets->Append(BitUtil::RoundDown(offset, 8) / 8));
-      RETURN_NOT_OK(range_lengths->Append(BitUtil::CoveringBytes(offset, length)));
+      RETURN_NOT_OK(range_offsets->Append(bit_util::RoundDown(offset, 8) / 8));
+      RETURN_NOT_OK(range_lengths->Append(bit_util::CoveringBytes(offset, length)));
     }
     return Status::OK();
   }
@@ -131,10 +131,10 @@ struct GetByteRangesArray {
   Status VisitFixedWidthArray(const Buffer& buffer, const FixedWidthType& type) const {
     uint64_t data_start = reinterpret_cast<uint64_t>(buffer.data());
     uint64_t offset_bits = offset * type.bit_width();
-    uint64_t offset_bytes = BitUtil::RoundDown(static_cast<int64_t>(offset_bits), 8) / 8;
+    uint64_t offset_bytes = bit_util::RoundDown(static_cast<int64_t>(offset_bits), 8) / 8;
     uint64_t end_byte =
-        BitUtil::RoundUp(static_cast<int64_t>(offset_bits + (length * type.bit_width())),
-                         8) /
+        bit_util::RoundUp(static_cast<int64_t>(offset_bits + (length * type.bit_width())),
+                          8) /
         8;
     uint64_t length_bytes = (end_byte - offset_bytes);
     RETURN_NOT_OK(range_starts->Append(data_start));
diff --git a/cpp/src/arrow/util/compression_lz4.cc b/cpp/src/arrow/util/compression_lz4.cc
index c783e405590..86a0d51bd55 100644
--- a/cpp/src/arrow/util/compression_lz4.cc
+++ b/cpp/src/arrow/util/compression_lz4.cc
@@ -393,9 +393,9 @@ class Lz4HadoopCodec : public Lz4Codec {
     // Prepend decompressed size in bytes and compressed size in bytes
     // to be compatible with Hadoop Lz4Codec
     const uint32_t decompressed_size =
-        BitUtil::ToBigEndian(static_cast<uint32_t>(input_len));
+        bit_util::ToBigEndian(static_cast<uint32_t>(input_len));
     const uint32_t compressed_size =
-        BitUtil::ToBigEndian(static_cast<uint32_t>(output_len));
+        bit_util::ToBigEndian(static_cast<uint32_t>(output_len));
     SafeStore(output_buffer, decompressed_size);
     SafeStore(output_buffer + sizeof(uint32_t), compressed_size);
 
@@ -437,9 +437,9 @@ class Lz4HadoopCodec : public Lz4Codec {
 
     while (input_len >= kPrefixLength) {
       const uint32_t expected_decompressed_size =
-          BitUtil::FromBigEndian(SafeLoadAs<uint32_t>(input));
+          bit_util::FromBigEndian(SafeLoadAs<uint32_t>(input));
       const uint32_t expected_compressed_size =
-          BitUtil::FromBigEndian(SafeLoadAs<uint32_t>(input + sizeof(uint32_t)));
+          bit_util::FromBigEndian(SafeLoadAs<uint32_t>(input + sizeof(uint32_t)));
       input += kPrefixLength;
       input_len -= kPrefixLength;
 
diff --git a/cpp/src/arrow/util/config.h.cmake b/cpp/src/arrow/util/config.h.cmake
index de3b03ccb48..d8d7e6e6d80 100644
--- a/cpp/src/arrow/util/config.h.cmake
+++ b/cpp/src/arrow/util/config.h.cmake
@@ -44,5 +44,6 @@
 
 #cmakedefine ARROW_S3
 #cmakedefine ARROW_USE_NATIVE_INT128
+#cmakedefine ARROW_WITH_OPENTELEMETRY
 
 #cmakedefine GRPCPP_PP_INCLUDE
diff --git a/cpp/src/arrow/util/decimal.cc b/cpp/src/arrow/util/decimal.cc
index 3118db99408..d29ea65734c 100644
--- a/cpp/src/arrow/util/decimal.cc
+++ b/cpp/src/arrow/util/decimal.cc
@@ -267,7 +267,7 @@ static void AppendLittleEndianArrayToString(const std::array<uint64_t, n>& array
       // *elem = dividend / 1e9;
       // remainder = dividend % 1e9.
       uint32_t hi = static_cast<uint32_t>(*elem >> 32);
-      uint32_t lo = static_cast<uint32_t>(*elem & BitUtil::LeastSignificantBitMask(32));
+      uint32_t lo = static_cast<uint32_t>(*elem & bit_util::LeastSignificantBitMask(32));
       uint64_t dividend_hi = (static_cast<uint64_t>(remainder) << 32) | hi;
       uint64_t quotient_hi = dividend_hi / k1e9;
       remainder = static_cast<uint32_t>(dividend_hi % k1e9);
@@ -542,7 +542,7 @@ Status DecimalFromString(const char* type_name, const util::string_view& s, Deci
     ShiftAndAdd(dec.whole_digits, little_endian_array.data(), little_endian_array.size());
     ShiftAndAdd(dec.fractional_digits, little_endian_array.data(),
                 little_endian_array.size());
-    *out = Decimal(BitUtil::LittleEndianArray::ToNative(little_endian_array));
+    *out = Decimal(bit_util::little_endian::ToNative(little_endian_array));
     if (dec.sign == '-') {
       out->Negate();
     }
@@ -613,7 +613,7 @@ static inline uint64_t UInt64FromBigEndian(const uint8_t* bytes, int32_t length)
   // and doing the conversion in 16, 32 parts, which could
   // possibly create unaligned memory access on certain platforms
   memcpy(reinterpret_cast<uint8_t*>(&result) + 8 - length, bytes, length);
-  return ::arrow::BitUtil::FromBigEndian(result);
+  return ::arrow::bit_util::FromBigEndian(result);
 }
 
 Result<Decimal128> Decimal128::FromBigEndian(const uint8_t* bytes, int32_t length) {
@@ -689,10 +689,10 @@ std::string Decimal256::ToIntegerString() const {
     Decimal256 abs = *this;
     abs.Negate();
     AppendLittleEndianArrayToString(
-        BitUtil::LittleEndianArray::FromNative(abs.native_endian_array()), &result);
+        bit_util::little_endian::FromNative(abs.native_endian_array()), &result);
   } else {
     AppendLittleEndianArrayToString(
-        BitUtil::LittleEndianArray::FromNative(native_endian_array()), &result);
+        bit_util::little_endian::FromNative(native_endian_array()), &result);
   }
   return result;
 }
@@ -774,7 +774,7 @@ Result<Decimal256> Decimal256::FromBigEndian(const uint8_t* bytes, int32_t lengt
     length -= word_length;
   }
 
-  return Decimal256(BitUtil::LittleEndianArray::ToNative(little_endian_array));
+  return Decimal256(bit_util::little_endian::ToNative(little_endian_array));
 }
 
 Status Decimal256::ToArrowStatus(DecimalStatus dstatus) const {
@@ -817,7 +817,7 @@ struct Decimal256RealConversion {
     DCHECK_LT(part1, 1.8446744073709552e+19);  // 2**64
     DCHECK_GE(part0, 0);
     DCHECK_LT(part0, 1.8446744073709552e+19);  // 2**64
-    return Decimal256(BitUtil::LittleEndianArray::ToNative<uint64_t, 4>(
+    return Decimal256(bit_util::little_endian::ToNative<uint64_t, 4>(
         {static_cast<uint64_t>(part0), static_cast<uint64_t>(part1),
          static_cast<uint64_t>(part2), static_cast<uint64_t>(part3)}));
   }
@@ -841,7 +841,7 @@ struct Decimal256RealConversion {
   static Real ToRealPositive(const Decimal256& decimal, int32_t scale) {
     DCHECK_GE(decimal, 0);
     Real x = 0;
-    const auto parts_le = BitUtil::LittleEndianArray::Make(decimal.native_endian_array());
+    const auto parts_le = bit_util::little_endian::Make(decimal.native_endian_array());
     x += Derived::two_to_192(static_cast<Real>(parts_le[3]));
     x += Derived::two_to_128(static_cast<Real>(parts_le[2]));
     x += Derived::two_to_64(static_cast<Real>(parts_le[1]));
diff --git a/cpp/src/arrow/util/decimal_test.cc b/cpp/src/arrow/util/decimal_test.cc
index d4e042ad2b2..ca4f64228d1 100644
--- a/cpp/src/arrow/util/decimal_test.cc
+++ b/cpp/src/arrow/util/decimal_test.cc
@@ -1568,11 +1568,10 @@ TEST(Decimal256Test, TestComparators) {
   constexpr size_t num_values =
       sizeof(kSortedDecimal256Bits) / sizeof(kSortedDecimal256Bits[0]);
   for (size_t i = 0; i < num_values; ++i) {
-    Decimal256 left(
-        ::arrow::BitUtil::LittleEndianArray::ToNative(kSortedDecimal256Bits[i]));
+    Decimal256 left(::arrow::bit_util::little_endian::ToNative(kSortedDecimal256Bits[i]));
     for (size_t j = 0; j < num_values; ++j) {
       Decimal256 right(
-          ::arrow::BitUtil::LittleEndianArray::ToNative(kSortedDecimal256Bits[j]));
+          ::arrow::bit_util::little_endian::ToNative(kSortedDecimal256Bits[j]));
       EXPECT_EQ(i == j, left == right);
       EXPECT_EQ(i != j, left != right);
       EXPECT_EQ(i < j, left < right);
@@ -1585,7 +1584,7 @@ TEST(Decimal256Test, TestComparators) {
 
 TEST(Decimal256Test, TestToBytesRoundTrip) {
   for (const std::array<uint64_t, 4>& bits : kSortedDecimal256Bits) {
-    Decimal256 decimal(::arrow::BitUtil::LittleEndianArray::ToNative(bits));
+    Decimal256 decimal(::arrow::bit_util::little_endian::ToNative(bits));
     EXPECT_EQ(decimal, Decimal256(decimal.ToBytes().data()));
   }
 }
@@ -1608,20 +1607,20 @@ TYPED_TEST(Decimal256Test, ConstructibleFromAnyIntegerType) {
   using UInt64Array = std::array<uint64_t, 4>;
   Decimal256 value(TypeParam{42});
   EXPECT_EQ(UInt64Array({42, 0, 0, 0}),
-            ::arrow::BitUtil::LittleEndianArray::FromNative(value.native_endian_array()));
+            ::arrow::bit_util::little_endian::FromNative(value.native_endian_array()));
 
   TypeParam max = std::numeric_limits<TypeParam>::max();
   Decimal256 max_value(max);
   EXPECT_EQ(
       UInt64Array({static_cast<uint64_t>(max), 0, 0, 0}),
-      ::arrow::BitUtil::LittleEndianArray::FromNative(max_value.native_endian_array()));
+      ::arrow::bit_util::little_endian::FromNative(max_value.native_endian_array()));
 
   TypeParam min = std::numeric_limits<TypeParam>::min();
   Decimal256 min_value(min);
   uint64_t high_bits = std::is_signed<TypeParam>::value ? ~uint64_t{0} : uint64_t{0};
   EXPECT_EQ(
       UInt64Array({static_cast<uint64_t>(min), high_bits, high_bits, high_bits}),
-      ::arrow::BitUtil::LittleEndianArray::FromNative(min_value.native_endian_array()));
+      ::arrow::bit_util::little_endian::FromNative(min_value.native_endian_array()));
 }
 
 TEST(Decimal256Test, ConstructibleFromBool) {
diff --git a/cpp/src/arrow/util/endian.h b/cpp/src/arrow/util/endian.h
index 0fae454e0eb..f77077f8094 100644
--- a/cpp/src/arrow/util/endian.h
+++ b/cpp/src/arrow/util/endian.h
@@ -59,7 +59,7 @@
 #include "arrow/util/ubsan.h"
 
 namespace arrow {
-namespace BitUtil {
+namespace bit_util {
 
 //
 // Byte-swap 16-bit, 32-bit and 64-bit values
@@ -181,7 +181,7 @@ static inline T FromLittleEndian(T value) {
 #endif
 
 // Handle endianness in *word* granuality (keep individual array element untouched)
-namespace LittleEndianArray {
+namespace little_endian {
 
 namespace detail {
 
@@ -239,7 +239,7 @@ static inline std::array<T, N> FromNative(std::array<T, N> array) {
   return ToNative(array);
 }
 
-}  // namespace LittleEndianArray
+}  // namespace little_endian
 
-}  // namespace BitUtil
+}  // namespace bit_util
 }  // namespace arrow
diff --git a/cpp/src/arrow/util/hashing.h b/cpp/src/arrow/util/hashing.h
index 09076c54d3c..328d7e7ca21 100644
--- a/cpp/src/arrow/util/hashing.h
+++ b/cpp/src/arrow/util/hashing.h
@@ -97,7 +97,7 @@ struct ScalarHelper<Scalar, AlgNum, enable_if_t<std::is_integral<Scalar>::value>
     // then byte-swapping (which is a single CPU instruction) allows the
     // combined high and low bits to participate in the initial hash table index.
     auto h = static_cast<hash_t>(value);
-    return BitUtil::ByteSwap(multipliers[AlgNum] * h);
+    return bit_util::ByteSwap(multipliers[AlgNum] * h);
   }
 };
 
@@ -212,7 +212,7 @@ class HashTable {
     DCHECK_NE(pool, nullptr);
     // Minimum of 32 elements
     capacity = std::max<uint64_t>(capacity, 32UL);
-    capacity_ = BitUtil::NextPower2(capacity);
+    capacity_ = bit_util::NextPower2(capacity);
     capacity_mask_ = capacity_ - 1;
     size_ = 0;
 
diff --git a/cpp/src/arrow/util/int_util.cc b/cpp/src/arrow/util/int_util.cc
index 24c5fe56eff..f96521216db 100644
--- a/cpp/src/arrow/util/int_util.cc
+++ b/cpp/src/arrow/util/int_util.cc
@@ -656,20 +656,20 @@ Status IntegersInRange(const Datum& datum, CType bound_lower, CType bound_upper)
         // Let the compiler unroll this
         for (int j = 0; j < 8; ++j) {
           block_out_of_bounds |= IsOutOfBoundsMaybeNull(
-              indices_data[i], BitUtil::GetBit(bitmap, offset_position + i));
+              indices_data[i], bit_util::GetBit(bitmap, offset_position + i));
           ++i;
         }
       }
       for (; i < block.length; ++i) {
         block_out_of_bounds |= IsOutOfBoundsMaybeNull(
-            indices_data[i], BitUtil::GetBit(bitmap, offset_position + i));
+            indices_data[i], bit_util::GetBit(bitmap, offset_position + i));
       }
     }
     if (ARROW_PREDICT_FALSE(block_out_of_bounds)) {
       if (indices.GetNullCount() > 0) {
         for (int64_t i = 0; i < block.length; ++i) {
           if (IsOutOfBoundsMaybeNull(indices_data[i],
-                                     BitUtil::GetBit(bitmap, offset_position + i))) {
+                                     bit_util::GetBit(bitmap, offset_position + i))) {
             return GetErrorMessage(indices_data[i]);
           }
         }
diff --git a/cpp/src/arrow/util/int_util_test.cc b/cpp/src/arrow/util/int_util_test.cc
index 333154c5cec..fc6f069242a 100644
--- a/cpp/src/arrow/util/int_util_test.cc
+++ b/cpp/src/arrow/util/int_util_test.cc
@@ -411,7 +411,7 @@ TEST(CheckIndexBounds, Batching) {
 
   int16_t* values = index_data->GetMutableValues<int16_t>(1);
   uint8_t* bitmap = index_data->buffers[0]->mutable_data();
-  BitUtil::SetBitsTo(bitmap, 0, length, true);
+  bit_util::SetBitsTo(bitmap, 0, length, true);
 
   ASSERT_OK(CheckIndexBounds(*index_data, 1));
 
@@ -420,14 +420,14 @@ TEST(CheckIndexBounds, Batching) {
   ASSERT_RAISES(IndexError, CheckIndexBounds(*index_data, 1));
 
   // Make that value null
-  BitUtil::ClearBit(bitmap, 99);
+  bit_util::ClearBit(bitmap, 99);
   ASSERT_OK(CheckIndexBounds(*index_data, 1));
 
   values[199] = 1;
   ASSERT_RAISES(IndexError, CheckIndexBounds(*index_data, 1));
 
   // Make that value null
-  BitUtil::ClearBit(bitmap, 199);
+  bit_util::ClearBit(bitmap, 199);
   ASSERT_OK(CheckIndexBounds(*index_data, 1));
 }
 
@@ -513,7 +513,7 @@ TEST(CheckIntegersInRange, Batching) {
 
   int16_t* values = index_data->GetMutableValues<int16_t>(1);
   uint8_t* bitmap = index_data->buffers[0]->mutable_data();
-  BitUtil::SetBitsTo(bitmap, 0, length, true);
+  bit_util::SetBitsTo(bitmap, 0, length, true);
 
   auto zero = std::make_shared<Int16Scalar>(0);
   auto one = std::make_shared<Int16Scalar>(1);
@@ -529,14 +529,14 @@ TEST(CheckIntegersInRange, Batching) {
   ASSERT_RAISES(Invalid, CheckIntegersInRange(*index_data, *zero, *one));
 
   // Make that value null
-  BitUtil::ClearBit(bitmap, 99);
+  bit_util::ClearBit(bitmap, 99);
   ASSERT_OK(CheckIntegersInRange(*index_data, *zero, *one));
 
   values[199] = 2;
   ASSERT_RAISES(Invalid, CheckIntegersInRange(*index_data, *zero, *one));
 
   // Make that value null
-  BitUtil::ClearBit(bitmap, 199);
+  bit_util::ClearBit(bitmap, 199);
   ASSERT_OK(CheckIntegersInRange(*index_data, *zero, *one));
 }
 
diff --git a/cpp/src/arrow/util/rle_encoding.h b/cpp/src/arrow/util/rle_encoding.h
index e9018fdf0ae..cc90f658f0c 100644
--- a/cpp/src/arrow/util/rle_encoding.h
+++ b/cpp/src/arrow/util/rle_encoding.h
@@ -139,7 +139,7 @@ class RleDecoder {
                              int64_t valid_bits_offset);
 
  protected:
-  BitUtil::BitReader bit_reader_;
+  bit_util::BitReader bit_reader_;
   /// Number of bits needed to encode the value. Must be between 0 and 64.
   int bit_width_;
   uint64_t current_value_;
@@ -188,10 +188,10 @@ class RleEncoder {
     /// 1 indicator byte and MAX_VALUES_PER_LITERAL_RUN 'bit_width' values.
     int max_literal_run_size =
         1 +
-        static_cast<int>(BitUtil::BytesForBits(MAX_VALUES_PER_LITERAL_RUN * bit_width));
+        static_cast<int>(bit_util::BytesForBits(MAX_VALUES_PER_LITERAL_RUN * bit_width));
     /// Up to kMaxVlqByteLength indicator and a single 'bit_width' value.
-    int max_repeated_run_size = BitUtil::BitReader::kMaxVlqByteLength +
-                                static_cast<int>(BitUtil::BytesForBits(bit_width));
+    int max_repeated_run_size = bit_util::BitReader::kMaxVlqByteLength +
+                                static_cast<int>(bit_util::BytesForBits(bit_width));
     return std::max(max_literal_run_size, max_repeated_run_size);
   }
 
@@ -201,15 +201,15 @@ class RleEncoder {
     // and then a repeated run of length 8".
     // 8 values per smallest run, 8 bits per byte
     int bytes_per_run = bit_width;
-    int num_runs = static_cast<int>(BitUtil::CeilDiv(num_values, 8));
+    int num_runs = static_cast<int>(bit_util::CeilDiv(num_values, 8));
     int literal_max_size = num_runs + num_runs * bytes_per_run;
 
     // In the very worst case scenario, the data is a concatenation of repeated
     // runs of 8 values. Repeated run has a 1 byte varint followed by the
     // bit-packed repeated value
-    int min_repeated_run_size = 1 + static_cast<int>(BitUtil::BytesForBits(bit_width));
+    int min_repeated_run_size = 1 + static_cast<int>(bit_util::BytesForBits(bit_width));
     int repeated_max_size =
-        static_cast<int>(BitUtil::CeilDiv(num_values, 8)) * min_repeated_run_size;
+        static_cast<int>(bit_util::CeilDiv(num_values, 8)) * min_repeated_run_size;
 
     return std::max(literal_max_size, repeated_max_size);
   }
@@ -259,7 +259,7 @@ class RleEncoder {
   const int bit_width_;
 
   /// Underlying buffer.
-  BitUtil::BitWriter bit_writer_;
+  bit_util::BitWriter bit_writer_;
 
   /// If true, the buffer is full and subsequent Put()'s will fail.
   bool buffer_full_;
@@ -660,7 +660,7 @@ bool RleDecoder::NextCounts() {
     }
     repeat_count_ = count;
     T value = {};
-    if (!bit_reader_.GetAligned<T>(static_cast<int>(BitUtil::CeilDiv(bit_width_, 8)),
+    if (!bit_reader_.GetAligned<T>(static_cast<int>(bit_util::CeilDiv(bit_width_, 8)),
                                    &value)) {
       return false;
     }
@@ -739,7 +739,7 @@ inline void RleEncoder::FlushRepeatedRun() {
   int32_t indicator_value = repeat_count_ << 1 | 0;
   result &= bit_writer_.PutVlqInt(static_cast<uint32_t>(indicator_value));
   result &= bit_writer_.PutAligned(current_value_,
-                                   static_cast<int>(BitUtil::CeilDiv(bit_width_, 8)));
+                                   static_cast<int>(bit_util::CeilDiv(bit_width_, 8)));
   DCHECK(result);
   num_buffered_values_ = 0;
   repeat_count_ = 0;
diff --git a/cpp/src/arrow/util/rle_encoding_test.cc b/cpp/src/arrow/util/rle_encoding_test.cc
index 362f8253ccd..52f355daf21 100644
--- a/cpp/src/arrow/util/rle_encoding_test.cc
+++ b/cpp/src/arrow/util/rle_encoding_test.cc
@@ -42,7 +42,7 @@ TEST(BitArray, TestBool) {
   const int len = 8;
   uint8_t buffer[len];
 
-  BitUtil::BitWriter writer(buffer, len);
+  bit_util::BitWriter writer(buffer, len);
 
   // Write alternating 0's and 1's
   for (int i = 0; i < 8; ++i) {
@@ -75,7 +75,7 @@ TEST(BitArray, TestBool) {
   EXPECT_EQ(buffer[1], 0xCC /* 0b11001100 */);
 
   // Use the reader and validate
-  BitUtil::BitReader reader(buffer, len);
+  bit_util::BitReader reader(buffer, len);
   for (int i = 0; i < 8; ++i) {
     bool val = false;
     bool result = reader.GetValue(1, &val);
@@ -103,12 +103,12 @@ TEST(BitArray, TestBool) {
 
 // Writes 'num_vals' values with width 'bit_width' and reads them back.
 void TestBitArrayValues(int bit_width, int num_vals) {
-  int len = static_cast<int>(BitUtil::BytesForBits(bit_width * num_vals));
+  int len = static_cast<int>(bit_util::BytesForBits(bit_width * num_vals));
   EXPECT_GT(len, 0);
   const uint64_t mod = bit_width == 64 ? 1 : 1LL << bit_width;
 
   std::vector<uint8_t> buffer(len);
-  BitUtil::BitWriter writer(buffer.data(), len);
+  bit_util::BitWriter writer(buffer.data(), len);
   for (int i = 0; i < num_vals; ++i) {
     bool result = writer.PutValue(i % mod, bit_width);
     EXPECT_TRUE(result);
@@ -116,7 +116,7 @@ void TestBitArrayValues(int bit_width, int num_vals) {
   writer.Flush();
   EXPECT_EQ(writer.bytes_written(), len);
 
-  BitUtil::BitReader reader(buffer.data(), len);
+  bit_util::BitReader reader(buffer.data(), len);
   for (int i = 0; i < num_vals; ++i) {
     int64_t val = 0;
     bool result = reader.GetValue(bit_width, &val);
@@ -142,7 +142,7 @@ TEST(BitArray, TestMixed) {
   uint8_t buffer[len];
   bool parity = true;
 
-  BitUtil::BitWriter writer(buffer, len);
+  bit_util::BitWriter writer(buffer, len);
   for (int i = 0; i < len; ++i) {
     bool result;
     if (i % 2 == 0) {
@@ -156,7 +156,7 @@ TEST(BitArray, TestMixed) {
   writer.Flush();
 
   parity = true;
-  BitUtil::BitReader reader(buffer, len);
+  bit_util::BitReader reader(buffer, len);
   for (int i = 0; i < len; ++i) {
     bool result;
     if (i % 2 == 0) {
@@ -285,14 +285,14 @@ TEST(Rle, SpecificSequences) {
 
   for (int width = 9; width <= MAX_WIDTH; ++width) {
     ValidateRle(values, width, nullptr,
-                2 * (1 + static_cast<int>(BitUtil::CeilDiv(width, 8))));
+                2 * (1 + static_cast<int>(bit_util::CeilDiv(width, 8))));
   }
 
   // Test 100 0's and 1's alternating
   for (int i = 0; i < 100; ++i) {
     values[i] = i % 2;
   }
-  int num_groups = static_cast<int>(BitUtil::CeilDiv(100, 8));
+  int num_groups = static_cast<int>(bit_util::CeilDiv(100, 8));
   expected_buffer[0] = static_cast<uint8_t>((num_groups << 1) | 1);
   for (int i = 1; i <= 100 / 8; ++i) {
     expected_buffer[i] = 0xAA /* 0b10101010 */;
@@ -303,9 +303,9 @@ TEST(Rle, SpecificSequences) {
   // num_groups and expected_buffer only valid for bit width = 1
   ValidateRle(values, 1, expected_buffer, 1 + num_groups);
   for (int width = 2; width <= MAX_WIDTH; ++width) {
-    int num_values = static_cast<int>(BitUtil::CeilDiv(100, 8)) * 8;
+    int num_values = static_cast<int>(bit_util::CeilDiv(100, 8)) * 8;
     ValidateRle(values, width, nullptr,
-                1 + static_cast<int>(BitUtil::CeilDiv(width * num_values, 8)));
+                1 + static_cast<int>(bit_util::CeilDiv(width * num_values, 8)));
   }
 
   // Test 16-bit values to confirm encoded values are stored in little endian
@@ -439,7 +439,7 @@ TEST(BitRle, Random) {
       }
       parity = !parity;
     }
-    if (!CheckRoundTrip(values, BitUtil::NumRequiredBits(values.size()))) {
+    if (!CheckRoundTrip(values, bit_util::NumRequiredBits(values.size()))) {
       FAIL() << "failing seed: " << seed;
     }
   }
diff --git a/cpp/src/arrow/util/tracing_internal.cc b/cpp/src/arrow/util/tracing_internal.cc
new file mode 100644
index 00000000000..fe6422eaa35
--- /dev/null
+++ b/cpp/src/arrow/util/tracing_internal.cc
@@ -0,0 +1,139 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/util/tracing_internal.h"
+
+#include <iostream>
+#include <sstream>
+#include <thread>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4522)
+#endif
+#include <opentelemetry/exporters/otlp/otlp_http_exporter.h>
+#include <opentelemetry/sdk/trace/batch_span_processor.h>
+#include <opentelemetry/sdk/trace/recordable.h>
+#include <opentelemetry/sdk/trace/span_data.h>
+#include <opentelemetry/sdk/trace/tracer_provider.h>
+#include <opentelemetry/trace/noop.h>
+#include <opentelemetry/trace/provider.h>
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#include "arrow/util/io_util.h"
+#include "arrow/util/logging.h"
+#include "arrow/util/make_unique.h"
+
+namespace arrow {
+namespace internal {
+namespace tracing {
+
+namespace nostd = opentelemetry::nostd;
+namespace otel = opentelemetry;
+
+constexpr char kTracingBackendEnvVar[] = "ARROW_TRACING_BACKEND";
+
+namespace {
+
+namespace sdktrace = opentelemetry::sdk::trace;
+
+class ThreadIdSpanProcessor : public sdktrace::BatchSpanProcessor {
+ public:
+  using sdktrace::BatchSpanProcessor::BatchSpanProcessor;
+  void OnEnd(std::unique_ptr<sdktrace::Recordable>&& span) noexcept override {
+    std::stringstream thread_id;
+    thread_id << std::this_thread::get_id();
+    span->SetAttribute("thread_id", thread_id.str());
+    sdktrace::BatchSpanProcessor::OnEnd(std::move(span));
+  }
+};
+
+std::unique_ptr<sdktrace::SpanExporter> InitializeExporter() {
+  auto maybe_env_var = arrow::internal::GetEnvVar(kTracingBackendEnvVar);
+  if (maybe_env_var.ok()) {
+    auto env_var = maybe_env_var.ValueOrDie();
+    if (env_var == "otlp_http") {
+#ifdef ARROW_WITH_OPENTELEMETRY
+      namespace otlp = opentelemetry::exporter::otlp;
+      otlp::OtlpHttpExporterOptions opts;
+      return arrow::internal::make_unique<otlp::OtlpHttpExporter>(opts);
+#else
+      ARROW_LOG(WARNING) << "Requested " << kTracingBackendEnvVar << "=" < < < < env_var
+          " but Arrow was not built with ARROW_WITH_OPENTELEMETRY";
+#endif
+    } else if (!env_var.empty()) {
+      ARROW_LOG(WARNING) << "Requested unknown backend " << kTracingBackendEnvVar << "="
+                         << env_var;
+    }
+  }
+  return nullptr;
+}
+
+nostd::shared_ptr<sdktrace::TracerProvider> InitializeSdkTracerProvider() {
+  auto exporter = InitializeExporter();
+  if (exporter) {
+    sdktrace::BatchSpanProcessorOptions options;
+    options.max_queue_size = 16384;
+    options.schedule_delay_millis = std::chrono::milliseconds(500);
+    options.max_export_batch_size = 16384;
+    auto processor =
+        arrow::internal::make_unique<ThreadIdSpanProcessor>(std::move(exporter), options);
+    return std::make_shared<sdktrace::TracerProvider>(std::move(processor));
+  }
+  return nostd::shared_ptr<sdktrace::TracerProvider>();
+}
+
+class FlushLog {
+ public:
+  explicit FlushLog(nostd::shared_ptr<sdktrace::TracerProvider> provider)
+      : provider_(std::move(provider)) {}
+  ~FlushLog() {
+    if (provider_) {
+      provider_->ForceFlush(std::chrono::microseconds(1000000));
+    }
+  }
+  nostd::shared_ptr<sdktrace::TracerProvider> provider_;
+};
+
+nostd::shared_ptr<sdktrace::TracerProvider> GetSdkTracerProvider() {
+  static FlushLog flush_log = FlushLog(InitializeSdkTracerProvider());
+  return flush_log.provider_;
+}
+
+nostd::shared_ptr<otel::trace::TracerProvider> InitializeTracing() {
+  nostd::shared_ptr<otel::trace::TracerProvider> provider = GetSdkTracerProvider();
+  if (provider) otel::trace::Provider::SetTracerProvider(provider);
+  return otel::trace::Provider::GetTracerProvider();
+}
+
+otel::trace::TracerProvider* GetTracerProvider() {
+  static nostd::shared_ptr<otel::trace::TracerProvider> provider = InitializeTracing();
+  return provider.get();
+}
+}  // namespace
+
+opentelemetry::trace::Tracer* GetTracer() {
+  static nostd::shared_ptr<opentelemetry::trace::Tracer> tracer =
+      GetTracerProvider()->GetTracer("arrow");
+  return tracer.get();
+}
+
+}  // namespace tracing
+}  // namespace internal
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/tracing_internal.h b/cpp/src/arrow/util/tracing_internal.h
new file mode 100644
index 00000000000..f3ca5e5ce3d
--- /dev/null
+++ b/cpp/src/arrow/util/tracing_internal.h
@@ -0,0 +1,104 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <memory>
+
+// Pick up ARROW_WITH_OPENTELEMETRY first
+#include "arrow/util/config.h"
+
+#ifdef ARROW_WITH_OPENTELEMETRY
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4522)
+#endif
+#include <opentelemetry/trace/provider.h>
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+#endif
+
+#include "arrow/util/async_generator.h"
+#include "arrow/util/iterator.h"
+#include "arrow/util/visibility.h"
+
+namespace arrow {
+namespace internal {
+namespace tracing {
+
+#ifdef ARROW_WITH_OPENTELEMETRY
+ARROW_EXPORT
+opentelemetry::trace::Tracer* GetTracer();
+
+inline void MarkSpan(const Status& s, opentelemetry::trace::Span* span) {
+  if (!s.ok()) {
+    span->SetStatus(opentelemetry::trace::StatusCode::kError, s.ToString());
+  } else {
+    span->SetStatus(opentelemetry::trace::StatusCode::kOk);
+  }
+}
+
+template <typename T>
+inline Result<T> MarkSpan(Result<T> result, opentelemetry::trace::Span* span) {
+  MarkSpan(result.status(), span);
+  return result;
+}
+
+template <typename T>
+Iterator<T> WrapIterator(
+    Iterator<T> wrapped,
+    opentelemetry::nostd::shared_ptr<opentelemetry::trace::Span> parent_span,
+    const std::string& span_name) {
+  struct {
+    Result<T> operator()() {
+      opentelemetry::trace::StartSpanOptions options;
+      options.parent = parent_span->GetContext();
+      auto span = GetTracer()->StartSpan(span_name, options);
+      auto scope = GetTracer()->WithActiveSpan(span);
+      return wrapped.Next();
+    }
+
+    Iterator<T> wrapped;
+    opentelemetry::nostd::shared_ptr<opentelemetry::trace::Span> parent_span;
+    std::string span_name;
+  } Wrapper;
+  Wrapper.wrapped = std::move(wrapped);
+  Wrapper.parent_span = std::move(parent_span);
+  Wrapper.span_name = span_name;
+  return MakeFunctionIterator(std::move(Wrapper));
+}
+
+template <typename T>
+AsyncGenerator<T> WrapAsyncGenerator(AsyncGenerator<T> wrapped,
+                                     const std::string& span_name) {
+  return [=]() mutable -> Future<T> {
+    auto span = GetTracer()->StartSpan(span_name);
+    auto scope = GetTracer()->WithActiveSpan(span);
+    auto fut = wrapped();
+    fut.AddCallback([span](const Result<T>& result) {
+      MarkSpan(result.status(), span.get());
+      span->End();
+    });
+    return fut;
+  };
+}
+#endif
+
+}  // namespace tracing
+}  // namespace internal
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/utf8.h b/cpp/src/arrow/util/utf8.h
index 45cdcd83357..91ea327bbb3 100644
--- a/cpp/src/arrow/util/utf8.h
+++ b/cpp/src/arrow/util/utf8.h
@@ -320,6 +320,19 @@ static inline bool Utf8Is4ByteStart(const uint8_t codeunit) {
   return (codeunit & 0xF8) == 0xF0;  // upper five bits should be 11110
 }
 
+/// Return the number of bytes required to UTF8-encode the given codepoint
+static inline int32_t UTF8EncodedLength(uint32_t codepoint) {
+  if (codepoint < 0x80) {
+    return 1;
+  } else if (codepoint < 0x800) {
+    return 2;
+  } else if (codepoint < 0x10000) {
+    return 3;
+  } else {
+    return 4;
+  }
+}
+
 static inline uint8_t* UTF8Encode(uint8_t* str, uint32_t codepoint) {
   if (codepoint < 0x80) {
     *str++ = codepoint;
diff --git a/cpp/src/arrow/util/value_parsing.cc b/cpp/src/arrow/util/value_parsing.cc
index ccd7674aa7a..92495612a7d 100644
--- a/cpp/src/arrow/util/value_parsing.cc
+++ b/cpp/src/arrow/util/value_parsing.cc
@@ -25,13 +25,19 @@
 namespace arrow {
 namespace internal {
 
-bool StringToFloat(const char* s, size_t length, float* out) {
-  const auto res = ::arrow_vendored::fast_float::from_chars(s, s + length, *out);
+bool StringToFloat(const char* s, size_t length, char decimal_point, float* out) {
+  ::arrow_vendored::fast_float::parse_options options{
+      ::arrow_vendored::fast_float::chars_format::general, decimal_point};
+  const auto res =
+      ::arrow_vendored::fast_float::from_chars_advanced(s, s + length, *out, options);
   return res.ec == std::errc() && res.ptr == s + length;
 }
 
-bool StringToFloat(const char* s, size_t length, double* out) {
-  const auto res = ::arrow_vendored::fast_float::from_chars(s, s + length, *out);
+bool StringToFloat(const char* s, size_t length, char decimal_point, double* out) {
+  ::arrow_vendored::fast_float::parse_options options{
+      ::arrow_vendored::fast_float::chars_format::general, decimal_point};
+  const auto res =
+      ::arrow_vendored::fast_float::from_chars_advanced(s, s + length, *out, options);
   return res.ec == std::errc() && res.ptr == s + length;
 }
 
diff --git a/cpp/src/arrow/util/value_parsing.h b/cpp/src/arrow/util/value_parsing.h
index fd285713b11..fbbbcf10f00 100644
--- a/cpp/src/arrow/util/value_parsing.h
+++ b/cpp/src/arrow/util/value_parsing.h
@@ -93,7 +93,7 @@ template <>
 struct StringConverter<BooleanType> {
   using value_type = bool;
 
-  static bool Convert(const BooleanType&, const char* s, size_t length, value_type* out) {
+  bool Convert(const BooleanType&, const char* s, size_t length, value_type* out) {
     if (length == 1) {
       // "0" or "1"?
       if (s[0] == '0') {
@@ -129,27 +129,37 @@ struct StringConverter<BooleanType> {
 // - https://github.com/achan001/dtoa-fast
 
 ARROW_EXPORT
-bool StringToFloat(const char* s, size_t length, float* out);
+bool StringToFloat(const char* s, size_t length, char decimal_point, float* out);
 
 ARROW_EXPORT
-bool StringToFloat(const char* s, size_t length, double* out);
+bool StringToFloat(const char* s, size_t length, char decimal_point, double* out);
 
 template <>
 struct StringConverter<FloatType> {
   using value_type = float;
 
-  static bool Convert(const FloatType&, const char* s, size_t length, value_type* out) {
-    return ARROW_PREDICT_TRUE(StringToFloat(s, length, out));
+  explicit StringConverter(char decimal_point = '.') : decimal_point(decimal_point) {}
+
+  bool Convert(const FloatType&, const char* s, size_t length, value_type* out) {
+    return ARROW_PREDICT_TRUE(StringToFloat(s, length, decimal_point, out));
   }
+
+ private:
+  const char decimal_point;
 };
 
 template <>
 struct StringConverter<DoubleType> {
   using value_type = double;
 
-  static bool Convert(const DoubleType&, const char* s, size_t length, value_type* out) {
-    return ARROW_PREDICT_TRUE(StringToFloat(s, length, out));
+  explicit StringConverter(char decimal_point = '.') : decimal_point(decimal_point) {}
+
+  bool Convert(const DoubleType&, const char* s, size_t length, value_type* out) {
+    return ARROW_PREDICT_TRUE(StringToFloat(s, length, decimal_point, out));
   }
+
+ private:
+  const char decimal_point;
 };
 
 // NOTE: HalfFloatType would require a half<->float conversion library
@@ -302,7 +312,7 @@ template <class ARROW_TYPE>
 struct StringToUnsignedIntConverterMixin {
   using value_type = typename ARROW_TYPE::c_type;
 
-  static bool Convert(const ARROW_TYPE&, const char* s, size_t length, value_type* out) {
+  bool Convert(const ARROW_TYPE&, const char* s, size_t length, value_type* out) {
     if (ARROW_PREDICT_FALSE(length == 0)) {
       return false;
     }
@@ -350,7 +360,7 @@ struct StringToSignedIntConverterMixin {
   using value_type = typename ARROW_TYPE::c_type;
   using unsigned_type = typename std::make_unsigned<value_type>::type;
 
-  static bool Convert(const ARROW_TYPE&, const char* s, size_t length, value_type* out) {
+  bool Convert(const ARROW_TYPE&, const char* s, size_t length, value_type* out) {
     static constexpr auto max_positive =
         static_cast<unsigned_type>(std::numeric_limits<value_type>::max());
     // Assuming two's complement
@@ -806,8 +816,7 @@ template <>
 struct StringConverter<TimestampType> {
   using value_type = int64_t;
 
-  static bool Convert(const TimestampType& type, const char* s, size_t length,
-                      value_type* out) {
+  bool Convert(const TimestampType& type, const char* s, size_t length, value_type* out) {
     return ParseTimestampISO8601(s, length, type.unit(), out);
   }
 };
@@ -827,8 +836,7 @@ struct StringConverter<DATE_TYPE, enable_if_date<DATE_TYPE>> {
                                 arrow_vendored::date::days,
                                 std::chrono::milliseconds>::type;
 
-  static bool Convert(const DATE_TYPE& type, const char* s, size_t length,
-                      value_type* out) {
+  bool Convert(const DATE_TYPE& type, const char* s, size_t length, value_type* out) {
     if (ARROW_PREDICT_FALSE(length != 10)) {
       return false;
     }
@@ -860,8 +868,7 @@ struct StringConverter<TIME_TYPE, enable_if_time<TIME_TYPE>> {
   // We allow the following formats for unit == NANO:
   // - "hh:mm:ss.s{7,9}"
 
-  static bool Convert(const TIME_TYPE& type, const char* s, size_t length,
-                      value_type* out) {
+  bool Convert(const TIME_TYPE& type, const char* s, size_t length, value_type* out) {
     const auto unit = type.unit();
     std::chrono::seconds since_midnight;
 
@@ -906,14 +913,14 @@ struct StringConverter<TIME_TYPE, enable_if_time<TIME_TYPE>> {
 template <typename T>
 bool ParseValue(const T& type, const char* s, size_t length,
                 typename StringConverter<T>::value_type* out) {
-  return StringConverter<T>::Convert(type, s, length, out);
+  return StringConverter<T>{}.Convert(type, s, length, out);
 }
 
 template <typename T>
 enable_if_parameter_free<T, bool> ParseValue(
     const char* s, size_t length, typename StringConverter<T>::value_type* out) {
   static T type;
-  return StringConverter<T>::Convert(type, s, length, out);
+  return StringConverter<T>{}.Convert(type, s, length, out);
 }
 
 }  // namespace internal
diff --git a/cpp/src/arrow/util/value_parsing_test.cc b/cpp/src/arrow/util/value_parsing_test.cc
index 708d5ecd60f..2a986f3875c 100644
--- a/cpp/src/arrow/util/value_parsing_test.cc
+++ b/cpp/src/arrow/util/value_parsing_test.cc
@@ -15,7 +15,9 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <cmath>
 #include <string>
+#include <type_traits>
 #include <vector>
 
 #include <gtest/gtest.h>
@@ -27,12 +29,45 @@
 namespace arrow {
 namespace internal {
 
+template <typename T>
+void AssertValueEquals(T a, T b) {
+  ASSERT_EQ(a, b);
+}
+
+template <>
+void AssertValueEquals<float>(float a, float b) {
+  ASSERT_EQ(a, b);
+  ASSERT_EQ(std::signbit(a), std::signbit(b));
+}
+
+template <>
+void AssertValueEquals<double>(double a, double b) {
+  ASSERT_EQ(a, b);
+  ASSERT_EQ(std::signbit(a), std::signbit(b));
+}
+
+template <typename T>
+void AssertConversion(StringConverter<T>* converter, const T& type, const std::string& s,
+                      typename T::c_type expected) {
+  ARROW_SCOPED_TRACE("When converting: '", s, "', expecting: ", expected);
+  typename T::c_type out{};
+  ASSERT_TRUE(converter->Convert(type, s.data(), s.length(), &out));
+  AssertValueEquals(out, expected);
+}
+
+template <typename T>
+void AssertConversion(StringConverter<T>* converter, const std::string& s,
+                      typename T::c_type expected) {
+  auto type = checked_pointer_cast<T>(TypeTraits<T>::type_singleton());
+  AssertConversion(converter, *type, s, expected);
+}
+
 template <typename T>
 void AssertConversion(const T& type, const std::string& s, typename T::c_type expected) {
+  ARROW_SCOPED_TRACE("When converting: '", s, "', expecting: ", expected);
   typename T::c_type out{};
-  ASSERT_TRUE(ParseValue(type, s.data(), s.length(), &out))
-      << "Conversion failed for '" << s << "' (expected to return " << expected << ")";
-  ASSERT_EQ(out, expected) << "Conversion failed for '" << s << "'";
+  ASSERT_TRUE(ParseValue(type, s.data(), s.length(), &out));
+  AssertValueEquals(out, expected);
 }
 
 template <typename T>
@@ -41,6 +76,20 @@ void AssertConversion(const std::string& s, typename T::c_type expected) {
   AssertConversion(*type, s, expected);
 }
 
+template <typename T>
+void AssertConversionFails(StringConverter<T>* converter, const T& type,
+                           const std::string& s) {
+  typename T::c_type out{};
+  ASSERT_FALSE(converter->Convert(type, s.data(), s.length(), &out))
+      << "Conversion should have failed for '" << s << "' (returned " << out << ")";
+}
+
+template <typename T>
+void AssertConversionFails(StringConverter<T>* converter, const std::string& s) {
+  auto type = checked_pointer_cast<T>(TypeTraits<T>::type_singleton());
+  AssertConversionFails(converter, *type, s);
+}
+
 template <typename T>
 void AssertConversionFails(const T& type, const std::string& s) {
   typename T::c_type out{};
@@ -68,23 +117,33 @@ TEST(StringConversion, ToBoolean) {
 TEST(StringConversion, ToFloat) {
   AssertConversion<FloatType>("1.5", 1.5f);
   AssertConversion<FloatType>("0", 0.0f);
-  // XXX ASSERT_EQ doesn't distinguish signed zeros
   AssertConversion<FloatType>("-0.0", -0.0f);
   AssertConversion<FloatType>("-1e20", -1e20f);
 
   AssertConversionFails<FloatType>("");
   AssertConversionFails<FloatType>("e");
+  AssertConversionFails<FloatType>("1,5");
+
+  StringConverter<FloatType> converter(/*decimal_point=*/',');
+  AssertConversion(&converter, "1,5", 1.5f);
+  AssertConversion(&converter, "0", 0.0f);
+  AssertConversionFails(&converter, "1.5");
 }
 
 TEST(StringConversion, ToDouble) {
   AssertConversion<DoubleType>("1.5", 1.5);
   AssertConversion<DoubleType>("0", 0);
-  // XXX ASSERT_EQ doesn't distinguish signed zeros
   AssertConversion<DoubleType>("-0.0", -0.0);
   AssertConversion<DoubleType>("-1e100", -1e100);
 
   AssertConversionFails<DoubleType>("");
   AssertConversionFails<DoubleType>("e");
+  AssertConversionFails<DoubleType>("1,5");
+
+  StringConverter<DoubleType> converter(/*decimal_point=*/',');
+  AssertConversion(&converter, "1,5", 1.5);
+  AssertConversion(&converter, "0", 0.0);
+  AssertConversionFails(&converter, "1.5");
 }
 
 #if !defined(_WIN32) || defined(NDEBUG)
@@ -94,13 +153,25 @@ TEST(StringConversion, ToFloatLocale) {
   LocaleGuard locale_guard("fr_FR.UTF-8");
 
   AssertConversion<FloatType>("1.5", 1.5f);
+  AssertConversionFails<FloatType>("1,5");
+
+  StringConverter<FloatType> converter(/*decimal_point=*/'#');
+  AssertConversion(&converter, "1#5", 1.5f);
+  AssertConversionFails(&converter, "1.5");
+  AssertConversionFails(&converter, "1,5");
 }
 
 TEST(StringConversion, ToDoubleLocale) {
   // French locale uses the comma as decimal point
   LocaleGuard locale_guard("fr_FR.UTF-8");
 
-  AssertConversion<DoubleType>("1.5", 1.5f);
+  AssertConversion<DoubleType>("1.5", 1.5);
+  AssertConversionFails<DoubleType>("1,5");
+
+  StringConverter<DoubleType> converter(/*decimal_point=*/'#');
+  AssertConversion(&converter, "1#5", 1.5);
+  AssertConversionFails(&converter, "1.5");
+  AssertConversionFails(&converter, "1,5");
 }
 
 #endif  // _WIN32
diff --git a/cpp/src/arrow/vendored/fast_float/README.md b/cpp/src/arrow/vendored/fast_float/README.md
index 7d2e70541ba..c1c7316386c 100644
--- a/cpp/src/arrow/vendored/fast_float/README.md
+++ b/cpp/src/arrow/vendored/fast_float/README.md
@@ -1,5 +1,5 @@
 The files in this directory are vendored from fast_float
-git changeset `d4bc0f28a276ac05f8663826eadef324de3a3399`.
+git tag `v3.4.0`.
 
 See https://github.com/fastfloat/fast_float
 
diff --git a/cpp/src/arrow/vendored/fast_float/ascii_number.h b/cpp/src/arrow/vendored/fast_float/ascii_number.h
index 8a5afdee965..92a76654fa4 100644
--- a/cpp/src/arrow/vendored/fast_float/ascii_number.h
+++ b/cpp/src/arrow/vendored/fast_float/ascii_number.h
@@ -1,10 +1,10 @@
 #ifndef FASTFLOAT_ASCII_NUMBER_H
 #define FASTFLOAT_ASCII_NUMBER_H
 
-#include <cstdio>
 #include <cctype>
 #include <cstdint>
 #include <cstring>
+#include <iterator>
 
 #include "float_common.h"
 
@@ -15,6 +15,34 @@ namespace fast_float {
 // able to optimize it well.
 fastfloat_really_inline bool is_integer(char c)  noexcept  { return c >= '0' && c <= '9'; }
 
+fastfloat_really_inline uint64_t byteswap(uint64_t val) {
+  return (val & 0xFF00000000000000) >> 56
+    | (val & 0x00FF000000000000) >> 40
+    | (val & 0x0000FF0000000000) >> 24
+    | (val & 0x000000FF00000000) >> 8
+    | (val & 0x00000000FF000000) << 8
+    | (val & 0x0000000000FF0000) << 24
+    | (val & 0x000000000000FF00) << 40
+    | (val & 0x00000000000000FF) << 56;
+}
+
+fastfloat_really_inline uint64_t read_u64(const char *chars) {
+  uint64_t val;
+  ::memcpy(&val, chars, sizeof(uint64_t));
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+  // Need to read as-if the number was in little-endian order.
+  val = byteswap(val);
+#endif
+  return val;
+}
+
+fastfloat_really_inline void write_u64(uint8_t *chars, uint64_t val) {
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+  // Need to read as-if the number was in little-endian order.
+  val = byteswap(val);
+#endif
+  ::memcpy(chars, &val, sizeof(uint64_t));
+}
 
 // credit  @aqrit
 fastfloat_really_inline uint32_t  parse_eight_digits_unrolled(uint64_t val) {
@@ -28,47 +56,50 @@ fastfloat_really_inline uint32_t  parse_eight_digits_unrolled(uint64_t val) {
 }
 
 fastfloat_really_inline uint32_t parse_eight_digits_unrolled(const char *chars)  noexcept  {
-  uint64_t val;
-  ::memcpy(&val, chars, sizeof(uint64_t));
-  return parse_eight_digits_unrolled(val);
+  return parse_eight_digits_unrolled(read_u64(chars));
 }
 
 // credit @aqrit
 fastfloat_really_inline bool is_made_of_eight_digits_fast(uint64_t val)  noexcept  {
   return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) &
-     0x8080808080808080)); 
+     0x8080808080808080));
 }
 
 fastfloat_really_inline bool is_made_of_eight_digits_fast(const char *chars)  noexcept  {
-  uint64_t val;
-  ::memcpy(&val, chars, 8);
-  return is_made_of_eight_digits_fast(val);
+  return is_made_of_eight_digits_fast(read_u64(chars));
 }
 
+typedef span<const char> byte_span;
+
 struct parsed_number_string {
-  int64_t exponent;
-  uint64_t mantissa;
-  const char *lastmatch;
-  bool negative;
-  bool valid;
-  bool too_many_digits;
+  int64_t exponent{0};
+  uint64_t mantissa{0};
+  const char *lastmatch{nullptr};
+  bool negative{false};
+  bool valid{false};
+  bool too_many_digits{false};
+  // contains the range of the significant digits
+  byte_span integer{};  // non-nullable
+  byte_span fraction{}; // nullable
 };
 
-
 // Assuming that you use no more than 19 digits, this will
 // parse an ASCII string.
 fastfloat_really_inline
-parsed_number_string parse_number_string(const char *p, const char *pend, chars_format fmt) noexcept {
+parsed_number_string parse_number_string(const char *p, const char *pend, parse_options options) noexcept {
+  const chars_format fmt = options.format;
+  const char decimal_point = options.decimal_point;
+
   parsed_number_string answer;
   answer.valid = false;
   answer.too_many_digits = false;
   answer.negative = (*p == '-');
-  if ((*p == '-') || (*p == '+')) {
+  if (*p == '-') { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
     ++p;
     if (p == pend) {
       return answer;
     }
-    if (!is_integer(*p) && (*p != '.')) { // a  sign must be followed by an integer or the dot
+    if (!is_integer(*p) && (*p != decimal_point)) { // a sign must be followed by an integer or the dot
       return answer;
     }
   }
@@ -76,6 +107,10 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
 
   uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad)
 
+  while ((std::distance(p, pend) >= 8) && is_made_of_eight_digits_fast(p)) {
+    i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
+    p += 8;
+  }
   while ((p != pend) && is_integer(*p)) {
     // a multiplication by 10 is cheaper than an arbitrary integer
     // multiplication
@@ -85,26 +120,24 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
   }
   const char *const end_of_integer_part = p;
   int64_t digit_count = int64_t(end_of_integer_part - start_digits);
+  answer.integer = byte_span(start_digits, size_t(digit_count));
   int64_t exponent = 0;
-  if ((p != pend) && (*p == '.')) {
+  if ((p != pend) && (*p == decimal_point)) {
     ++p;
-#if FASTFLOAT_IS_BIG_ENDIAN == 0
-    // Fast approach only tested under little endian systems
-    if ((p + 8 <= pend) && is_made_of_eight_digits_fast(p)) {
+    const char* before = p;
+    // can occur at most twice without overflowing, but let it occur more, since
+    // for integers with many digits, digit parsing is the primary bottleneck.
+    while ((std::distance(p, pend) >= 8) && is_made_of_eight_digits_fast(p)) {
       i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
       p += 8;
-      if ((p + 8 <= pend) && is_made_of_eight_digits_fast(p)) {
-        i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
-        p += 8;
-      }
     }
-#endif
     while ((p != pend) && is_integer(*p)) {
       uint8_t digit = uint8_t(*p - '0');
       ++p;
       i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
     }
-    exponent = end_of_integer_part + 1 - p;
+    exponent = before - p;
+    answer.fraction = byte_span(before, size_t(p - before));
     digit_count -= exponent;
   }
   // we must have encountered at least one integer!
@@ -119,7 +152,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
     if ((p != pend) && ('-' == *p)) {
       neg_exp = true;
       ++p;
-    } else if ((p != pend) && ('+' == *p)) {
+    } else if ((p != pend) && ('+' == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
       ++p;
     }
     if ((p == pend) || !is_integer(*p)) {
@@ -132,7 +165,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
     } else {
       while ((p != pend) && is_integer(*p)) {
         uint8_t digit = uint8_t(*p - '0');
-        if (exp_number < 0x10000) {
+        if (exp_number < 0x10000000) {
           exp_number = 10 * exp_number + digit;
         }
         ++p;
@@ -158,30 +191,33 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
     // We need to be mindful of the case where we only have zeroes...
     // E.g., 0.000000000...000.
     const char *start = start_digits;
-    while ((start != pend) && (*start == '0' || *start == '.')) {
+    while ((start != pend) && (*start == '0' || *start == decimal_point)) {
       if(*start == '0') { digit_count --; }
       start++;
     }
     if (digit_count > 19) {
       answer.too_many_digits = true;
       // Let us start again, this time, avoiding overflows.
+      // We don't need to check if is_integer, since we use the
+      // pre-tokenized spans from above.
       i = 0;
-      p = start_digits;
+      p = answer.integer.ptr;
+      const char* int_end = p + answer.integer.len();
       const uint64_t minimal_nineteen_digit_integer{1000000000000000000};
-      while((i < minimal_nineteen_digit_integer) && (p != pend) && is_integer(*p)) {
+      while((i < minimal_nineteen_digit_integer) && (p != int_end)) {
         i = i * 10 + uint64_t(*p - '0');
         ++p;
       }
       if (i >= minimal_nineteen_digit_integer) { // We have a big integers
         exponent = end_of_integer_part - p + exp_number;
       } else { // We have a value with a fractional component.
-          p++; // skip the '.'
-          const char *first_after_period = p;
-          while((i < minimal_nineteen_digit_integer) && (p != pend) && is_integer(*p)) {
+          p = answer.fraction.ptr;
+          const char* frac_end = p + answer.fraction.len();
+          while((i < minimal_nineteen_digit_integer) && (p != frac_end)) {
             i = i * 10 + uint64_t(*p - '0');
             ++p;
           }
-          exponent = first_after_period - p + exp_number;
+          exponent = answer.fraction.ptr - p + exp_number;
       }
       // We have now corrected both exponent and i, to a truncated value
     }
@@ -191,110 +227,6 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
   return answer;
 }
 
-
-// This should always succeed since it follows a call to parse_number_string
-// This function could be optimized. In particular, we could stop after 19 digits
-// and try to bail out. Furthermore, we should be able to recover the computed
-// exponent from the pass in parse_number_string.
-fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend) noexcept {
-  decimal answer;
-  answer.num_digits = 0;
-  answer.decimal_point = 0;
-  answer.truncated = false;
-  // any whitespace has been skipped.
-  answer.negative = (*p == '-');
-  if ((*p == '-') || (*p == '+')) {
-    ++p;
-  }
-  // skip leading zeroes
-  while ((p != pend) && (*p == '0')) {
-    ++p;
-  }
-  while ((p != pend) && is_integer(*p)) {
-    if (answer.num_digits < max_digits) {
-      answer.digits[answer.num_digits] = uint8_t(*p - '0');
-    }
-    answer.num_digits++;
-    ++p;
-  }
-  if ((p != pend) && (*p == '.')) {
-    ++p;
-    const char *first_after_period = p;
-    // if we have not yet encountered a zero, we have to skip it as well
-    if(answer.num_digits == 0) {
-      // skip zeros
-      while ((p != pend) && (*p == '0')) {
-       ++p;
-      }
-    }
-#if FASTFLOAT_IS_BIG_ENDIAN == 0
-    // We expect that this loop will often take the bulk of the running time
-    // because when a value has lots of digits, these digits often
-    while ((p + 8 <= pend) && (answer.num_digits + 8 < max_digits)) {
-      uint64_t val;
-      ::memcpy(&val, p, sizeof(uint64_t));
-      if(! is_made_of_eight_digits_fast(val)) { break; }
-      // We have eight digits, process them in one go!
-      val -= 0x3030303030303030;
-      ::memcpy(answer.digits + answer.num_digits, &val, sizeof(uint64_t));
-      answer.num_digits += 8;
-      p += 8;
-    }
-#endif
-    while ((p != pend) && is_integer(*p)) {
-      if (answer.num_digits < max_digits) {
-        answer.digits[answer.num_digits] = uint8_t(*p - '0');
-      }
-      answer.num_digits++;
-      ++p;
-    }
-    answer.decimal_point = int32_t(first_after_period - p);
-  }
-  // We want num_digits to be the number of significant digits, excluding
-  // leading *and* trailing zeros! Otherwise the truncated flag later is
-  // going to be misleading.
-  if(answer.num_digits > 0) {
-    // We potentially need the answer.num_digits > 0 guard because we
-    // prune leading zeros. So with answer.num_digits > 0, we know that
-    // we have at least one non-zero digit.
-    const char *preverse = p - 1;
-    int32_t trailing_zeros = 0;
-    while ((*preverse == '0') || (*preverse == '.')) {
-      if(*preverse == '0') { trailing_zeros++; };
-      --preverse;
-    }
-    answer.decimal_point += int32_t(answer.num_digits);
-    answer.num_digits -= uint32_t(trailing_zeros);
-  }
-  if(answer.num_digits > max_digits) {
-    answer.truncated = true;
-    answer.num_digits = max_digits;
-  }
-  if ((p != pend) && (('e' == *p) || ('E' == *p))) {
-    ++p;
-    bool neg_exp = false;
-    if ((p != pend) && ('-' == *p)) {
-      neg_exp = true;
-      ++p;
-    } else if ((p != pend) && ('+' == *p)) {
-      ++p;
-    }
-    int32_t exp_number = 0; // exponential part
-    while ((p != pend) && is_integer(*p)) {
-      uint8_t digit = uint8_t(*p - '0');
-      if (exp_number < 0x10000) {
-        exp_number = 10 * exp_number + digit;
-      }    
-      ++p;
-    }
-    answer.decimal_point += (neg_exp ? -exp_number : exp_number);
-  }
-  // In very rare cases, we may have fewer than 19 digits, we want to be able to reliably
-  // assume that all digits up to max_digit_without_overflow have been initialized.
-  for(uint32_t i = answer.num_digits; i < max_digit_without_overflow; i++) { answer.digits[i] = 0; }
-
-  return answer;
-}
 } // namespace fast_float
 } // namespace arrow_vendored
 
diff --git a/cpp/src/arrow/vendored/fast_float/bigint.h b/cpp/src/arrow/vendored/fast_float/bigint.h
new file mode 100644
index 00000000000..38ac5c8dffe
--- /dev/null
+++ b/cpp/src/arrow/vendored/fast_float/bigint.h
@@ -0,0 +1,592 @@
+#ifndef FASTFLOAT_BIGINT_H
+#define FASTFLOAT_BIGINT_H
+
+#include <algorithm>
+#include <cstdint>
+#include <climits>
+#include <cstring>
+
+#include "float_common.h"
+
+namespace arrow_vendored {
+namespace fast_float {
+
+// the limb width: we want efficient multiplication of double the bits in
+// limb, or for 64-bit limbs, at least 64-bit multiplication where we can
+// extract the high and low parts efficiently. this is every 64-bit
+// architecture except for sparc, which emulates 128-bit multiplication.
+// we might have platforms where `CHAR_BIT` is not 8, so let's avoid
+// doing `8 * sizeof(limb)`.
+#if defined(FASTFLOAT_64BIT) && !defined(__sparc)
+#define FASTFLOAT_64BIT_LIMB
+typedef uint64_t limb;
+constexpr size_t limb_bits = 64;
+#else
+#define FASTFLOAT_32BIT_LIMB
+typedef uint32_t limb;
+constexpr size_t limb_bits = 32;
+#endif
+
+typedef span<limb> limb_span;
+
+// number of bits in a bigint. this needs to be at least the number
+// of bits required to store the largest bigint, which is
+// `log2(10**(digits + max_exp))`, or `log2(10**(767 + 342))`, or
+// ~3600 bits, so we round to 4000.
+constexpr size_t bigint_bits = 4000;
+constexpr size_t bigint_limbs = bigint_bits / limb_bits;
+
+// vector-like type that is allocated on the stack. the entire
+// buffer is pre-allocated, and only the length changes.
+template <uint16_t size>
+struct stackvec {
+  limb data[size];
+  // we never need more than 150 limbs
+  uint16_t length{0};
+
+  stackvec() = default;
+  stackvec(const stackvec &) = delete;
+  stackvec &operator=(const stackvec &) = delete;
+  stackvec(stackvec &&) = delete;
+  stackvec &operator=(stackvec &&other) = delete;
+
+  // create stack vector from existing limb span.
+  stackvec(limb_span s) {
+    FASTFLOAT_ASSERT(try_extend(s));
+  }
+
+  limb& operator[](size_t index) noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    return data[index];
+  }
+  const limb& operator[](size_t index) const noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    return data[index];
+  }
+  // index from the end of the container
+  const limb& rindex(size_t index) const noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    size_t rindex = length - index - 1;
+    return data[rindex];
+  }
+
+  // set the length, without bounds checking.
+  void set_len(size_t len) noexcept {
+    length = uint16_t(len);
+  }
+  constexpr size_t len() const noexcept {
+    return length;
+  }
+  constexpr bool is_empty() const noexcept {
+    return length == 0;
+  }
+  constexpr size_t capacity() const noexcept {
+    return size;
+  }
+  // append item to vector, without bounds checking
+  void push_unchecked(limb value) noexcept {
+    data[length] = value;
+    length++;
+  }
+  // append item to vector, returning if item was added
+  bool try_push(limb value) noexcept {
+    if (len() < capacity()) {
+      push_unchecked(value);
+      return true;
+    } else {
+      return false;
+    }
+  }
+  // add items to the vector, from a span, without bounds checking
+  void extend_unchecked(limb_span s) noexcept {
+    limb* ptr = data + length;
+    ::memcpy((void*)ptr, (const void*)s.ptr, sizeof(limb) * s.len());
+    set_len(len() + s.len());
+  }
+  // try to add items to the vector, returning if items were added
+  bool try_extend(limb_span s) noexcept {
+    if (len() + s.len() <= capacity()) {
+      extend_unchecked(s);
+      return true;
+    } else {
+      return false;
+    }
+  }
+  // resize the vector, without bounds checking
+  // if the new size is longer than the vector, assign value to each
+  // appended item.
+  void resize_unchecked(size_t new_len, limb value) noexcept {
+    if (new_len > len()) {
+      size_t count = new_len - len();
+      limb* first = data + len();
+      limb* last = first + count;
+      ::std::fill(first, last, value);
+      set_len(new_len);
+    } else {
+      set_len(new_len);
+    }
+  }
+  // try to resize the vector, returning if the vector was resized.
+  bool try_resize(size_t new_len, limb value) noexcept {
+    if (new_len > capacity()) {
+      return false;
+    } else {
+      resize_unchecked(new_len, value);
+      return true;
+    }
+  }
+  // check if any limbs are non-zero after the given index.
+  // this needs to be done in reverse order, since the index
+  // is relative to the most significant limbs.
+  bool nonzero(size_t index) const noexcept {
+    while (index < len()) {
+      if (rindex(index) != 0) {
+        return true;
+      }
+      index++;
+    }
+    return false;
+  }
+  // normalize the big integer, so most-significant zero limbs are removed.
+  void normalize() noexcept {
+    while (len() > 0 && rindex(0) == 0) {
+      length--;
+    }
+  }
+};
+
+fastfloat_really_inline
+uint64_t empty_hi64(bool& truncated) noexcept {
+  truncated = false;
+  return 0;
+}
+
+fastfloat_really_inline
+uint64_t uint64_hi64(uint64_t r0, bool& truncated) noexcept {
+  truncated = false;
+  int shl = leading_zeroes(r0);
+  return r0 << shl;
+}
+
+fastfloat_really_inline
+uint64_t uint64_hi64(uint64_t r0, uint64_t r1, bool& truncated) noexcept {
+  int shl = leading_zeroes(r0);
+  if (shl == 0) {
+    truncated = r1 != 0;
+    return r0;
+  } else {
+    int shr = 64 - shl;
+    truncated = (r1 << shl) != 0;
+    return (r0 << shl) | (r1 >> shr);
+  }
+}
+
+fastfloat_really_inline
+uint64_t uint32_hi64(uint32_t r0, bool& truncated) noexcept {
+  return uint64_hi64(r0, truncated);
+}
+
+fastfloat_really_inline
+uint64_t uint32_hi64(uint32_t r0, uint32_t r1, bool& truncated) noexcept {
+  uint64_t x0 = r0;
+  uint64_t x1 = r1;
+  return uint64_hi64((x0 << 32) | x1, truncated);
+}
+
+fastfloat_really_inline
+uint64_t uint32_hi64(uint32_t r0, uint32_t r1, uint32_t r2, bool& truncated) noexcept {
+  uint64_t x0 = r0;
+  uint64_t x1 = r1;
+  uint64_t x2 = r2;
+  return uint64_hi64(x0, (x1 << 32) | x2, truncated);
+}
+
+// add two small integers, checking for overflow.
+// we want an efficient operation. for msvc, where
+// we don't have built-in intrinsics, this is still
+// pretty fast.
+fastfloat_really_inline
+limb scalar_add(limb x, limb y, bool& overflow) noexcept {
+  limb z;
+
+// gcc and clang
+#if defined(__has_builtin)
+  #if __has_builtin(__builtin_add_overflow)
+    overflow = __builtin_add_overflow(x, y, &z);
+    return z;
+  #endif
+#endif
+
+  // generic, this still optimizes correctly on MSVC.
+  z = x + y;
+  overflow = z < x;
+  return z;
+}
+
+// multiply two small integers, getting both the high and low bits.
+fastfloat_really_inline
+limb scalar_mul(limb x, limb y, limb& carry) noexcept {
+#ifdef FASTFLOAT_64BIT_LIMB
+  #if defined(__SIZEOF_INT128__)
+  // GCC and clang both define it as an extension.
+  __uint128_t z = __uint128_t(x) * __uint128_t(y) + __uint128_t(carry);
+  carry = limb(z >> limb_bits);
+  return limb(z);
+  #else
+  // fallback, no native 128-bit integer multiplication with carry.
+  // on msvc, this optimizes identically, somehow.
+  value128 z = full_multiplication(x, y);
+  bool overflow;
+  z.low = scalar_add(z.low, carry, overflow);
+  z.high += uint64_t(overflow);  // cannot overflow
+  carry = z.high;
+  return z.low;
+  #endif
+#else
+  uint64_t z = uint64_t(x) * uint64_t(y) + uint64_t(carry);
+  carry = limb(z >> limb_bits);
+  return limb(z);
+#endif
+}
+
+// add scalar value to bigint starting from offset.
+// used in grade school multiplication
+template <uint16_t size>
+inline bool small_add_from(stackvec<size>& vec, limb y, size_t start) noexcept {
+  size_t index = start;
+  limb carry = y;
+  bool overflow;
+  while (carry != 0 && index < vec.len()) {
+    vec[index] = scalar_add(vec[index], carry, overflow);
+    carry = limb(overflow);
+    index += 1;
+  }
+  if (carry != 0) {
+    FASTFLOAT_TRY(vec.try_push(carry));
+  }
+  return true;
+}
+
+// add scalar value to bigint.
+template <uint16_t size>
+fastfloat_really_inline bool small_add(stackvec<size>& vec, limb y) noexcept {
+  return small_add_from(vec, y, 0);
+}
+
+// multiply bigint by scalar value.
+template <uint16_t size>
+inline bool small_mul(stackvec<size>& vec, limb y) noexcept {
+  limb carry = 0;
+  for (size_t index = 0; index < vec.len(); index++) {
+    vec[index] = scalar_mul(vec[index], y, carry);
+  }
+  if (carry != 0) {
+    FASTFLOAT_TRY(vec.try_push(carry));
+  }
+  return true;
+}
+
+// add bigint to bigint starting from index.
+// used in grade school multiplication
+template <uint16_t size>
+bool large_add_from(stackvec<size>& x, limb_span y, size_t start) noexcept {
+  // the effective x buffer is from `xstart..x.len()`, so exit early
+  // if we can't get that current range.
+  if (x.len() < start || y.len() > x.len() - start) {
+      FASTFLOAT_TRY(x.try_resize(y.len() + start, 0));
+  }
+
+  bool carry = false;
+  for (size_t index = 0; index < y.len(); index++) {
+    limb xi = x[index + start];
+    limb yi = y[index];
+    bool c1 = false;
+    bool c2 = false;
+    xi = scalar_add(xi, yi, c1);
+    if (carry) {
+      xi = scalar_add(xi, 1, c2);
+    }
+    x[index + start] = xi;
+    carry = c1 | c2;
+  }
+
+  // handle overflow
+  if (carry) {
+    FASTFLOAT_TRY(small_add_from(x, 1, y.len() + start));
+  }
+  return true;
+}
+
+// add bigint to bigint.
+template <uint16_t size>
+fastfloat_really_inline bool large_add_from(stackvec<size>& x, limb_span y) noexcept {
+  return large_add_from(x, y, 0);
+}
+
+// grade-school multiplication algorithm
+template <uint16_t size>
+bool long_mul(stackvec<size>& x, limb_span y) noexcept {
+  limb_span xs = limb_span(x.data, x.len());
+  stackvec<size> z(xs);
+  limb_span zs = limb_span(z.data, z.len());
+
+  if (y.len() != 0) {
+    limb y0 = y[0];
+    FASTFLOAT_TRY(small_mul(x, y0));
+    for (size_t index = 1; index < y.len(); index++) {
+      limb yi = y[index];
+      stackvec<size> zi;
+      if (yi != 0) {
+        // re-use the same buffer throughout
+        zi.set_len(0);
+        FASTFLOAT_TRY(zi.try_extend(zs));
+        FASTFLOAT_TRY(small_mul(zi, yi));
+        limb_span zis = limb_span(zi.data, zi.len());
+        FASTFLOAT_TRY(large_add_from(x, zis, index));
+      }
+    }
+  }
+
+  x.normalize();
+  return true;
+}
+
+// grade-school multiplication algorithm
+template <uint16_t size>
+bool large_mul(stackvec<size>& x, limb_span y) noexcept {
+  if (y.len() == 1) {
+    FASTFLOAT_TRY(small_mul(x, y[0]));
+  } else {
+    FASTFLOAT_TRY(long_mul(x, y));
+  }
+  return true;
+}
+
+// big integer type. implements a small subset of big integer
+// arithmetic, using simple algorithms since asymptotically
+// faster algorithms are slower for a small number of limbs.
+// all operations assume the big-integer is normalized.
+struct bigint {
+  // storage of the limbs, in little-endian order.
+  stackvec<bigint_limbs> vec;
+
+  bigint(): vec() {}
+  bigint(const bigint &) = delete;
+  bigint &operator=(const bigint &) = delete;
+  bigint(bigint &&) = delete;
+  bigint &operator=(bigint &&other) = delete;
+
+  bigint(uint64_t value): vec() {
+#ifdef FASTFLOAT_64BIT_LIMB
+    vec.push_unchecked(value);
+#else
+    vec.push_unchecked(uint32_t(value));
+    vec.push_unchecked(uint32_t(value >> 32));
+#endif
+    vec.normalize();
+  }
+
+  // get the high 64 bits from the vector, and if bits were truncated.
+  // this is to get the significant digits for the float.
+  uint64_t hi64(bool& truncated) const noexcept {
+#ifdef FASTFLOAT_64BIT_LIMB
+    if (vec.len() == 0) {
+      return empty_hi64(truncated);
+    } else if (vec.len() == 1) {
+      return uint64_hi64(vec.rindex(0), truncated);
+    } else {
+      uint64_t result = uint64_hi64(vec.rindex(0), vec.rindex(1), truncated);
+      truncated |= vec.nonzero(2);
+      return result;
+    }
+#else
+    if (vec.len() == 0) {
+      return empty_hi64(truncated);
+    } else if (vec.len() == 1) {
+      return uint32_hi64(vec.rindex(0), truncated);
+    } else if (vec.len() == 2) {
+      return uint32_hi64(vec.rindex(0), vec.rindex(1), truncated);
+    } else {
+      uint64_t result = uint32_hi64(vec.rindex(0), vec.rindex(1), vec.rindex(2), truncated);
+      truncated |= vec.nonzero(3);
+      return result;
+    }
+#endif
+  }
+
+  // compare two big integers, returning the large value.
+  // assumes both are normalized. if the return value is
+  // negative, other is larger, if the return value is
+  // positive, this is larger, otherwise they are equal.
+  // the limbs are stored in little-endian order, so we
+  // must compare the limbs in ever order.
+  int compare(const bigint& other) const noexcept {
+    if (vec.len() > other.vec.len()) {
+      return 1;
+    } else if (vec.len() < other.vec.len()) {
+      return -1;
+    } else {
+      for (size_t index = vec.len(); index > 0; index--) {
+        limb xi = vec[index - 1];
+        limb yi = other.vec[index - 1];
+        if (xi > yi) {
+          return 1;
+        } else if (xi < yi) {
+          return -1;
+        }
+      }
+      return 0;
+    }
+  }
+
+  // shift left each limb n bits, carrying over to the new limb
+  // returns true if we were able to shift all the digits.
+  bool shl_bits(size_t n) noexcept {
+    // Internally, for each item, we shift left by n, and add the previous
+    // right shifted limb-bits.
+    // For example, we transform (for u8) shifted left 2, to:
+    //      b10100100 b01000010
+    //      b10 b10010001 b00001000
+    FASTFLOAT_DEBUG_ASSERT(n != 0);
+    FASTFLOAT_DEBUG_ASSERT(n < sizeof(limb) * 8);
+
+    size_t shl = n;
+    size_t shr = limb_bits - shl;
+    limb prev = 0;
+    for (size_t index = 0; index < vec.len(); index++) {
+      limb xi = vec[index];
+      vec[index] = (xi << shl) | (prev >> shr);
+      prev = xi;
+    }
+
+    limb carry = prev >> shr;
+    if (carry != 0) {
+      return vec.try_push(carry);
+    }
+    return true;
+  }
+
+  // move the limbs left by `n` limbs.
+  bool shl_limbs(size_t n) noexcept {
+    FASTFLOAT_DEBUG_ASSERT(n != 0);
+    if (n + vec.len() > vec.capacity()) {
+      return false;
+    } else if (!vec.is_empty()) {
+      // move limbs
+      limb* dst = vec.data + n;
+      const limb* src = vec.data;
+      ::memmove(dst, src, sizeof(limb) * vec.len());
+      // fill in empty limbs
+      limb* first = vec.data;
+      limb* last = first + n;
+      ::std::fill(first, last, 0);
+      vec.set_len(n + vec.len());
+      return true;
+    } else {
+      return true;
+    }
+  }
+
+  // move the limbs left by `n` bits.
+  bool shl(size_t n) noexcept {
+    size_t rem = n % limb_bits;
+    size_t div = n / limb_bits;
+    if (rem != 0) {
+      FASTFLOAT_TRY(shl_bits(rem));
+    }
+    if (div != 0) {
+      FASTFLOAT_TRY(shl_limbs(div));
+    }
+    return true;
+  }
+
+  // get the number of leading zeros in the bigint.
+  int ctlz() const noexcept {
+    if (vec.is_empty()) {
+      return 0;
+    } else {
+#ifdef FASTFLOAT_64BIT_LIMB
+      return leading_zeroes(vec.rindex(0));
+#else
+      // no use defining a specialized leading_zeroes for a 32-bit type.
+      uint64_t r0 = vec.rindex(0);
+      return leading_zeroes(r0 << 32);
+#endif
+    }
+  }
+
+  // get the number of bits in the bigint.
+  int bit_length() const noexcept {
+    int lz = ctlz();
+    return int(limb_bits * vec.len()) - lz;
+  }
+
+  bool mul(limb y) noexcept {
+    return small_mul(vec, y);
+  }
+
+  bool add(limb y) noexcept {
+    return small_add(vec, y);
+  }
+
+  // multiply as if by 2 raised to a power.
+  bool pow2(uint32_t exp) noexcept {
+    return shl(exp);
+  }
+
+  // multiply as if by 5 raised to a power.
+  bool pow5(uint32_t exp) noexcept {
+    // multiply by a power of 5
+    static constexpr uint32_t large_step = 135;
+    static constexpr uint64_t small_power_of_5[] = {
+      1UL, 5UL, 25UL, 125UL, 625UL, 3125UL, 15625UL, 78125UL, 390625UL,
+      1953125UL, 9765625UL, 48828125UL, 244140625UL, 1220703125UL,
+      6103515625UL, 30517578125UL, 152587890625UL, 762939453125UL,
+      3814697265625UL, 19073486328125UL, 95367431640625UL, 476837158203125UL,
+      2384185791015625UL, 11920928955078125UL, 59604644775390625UL,
+      298023223876953125UL, 1490116119384765625UL, 7450580596923828125UL,
+    };
+#ifdef FASTFLOAT_64BIT_LIMB
+    constexpr static limb large_power_of_5[] = {
+      1414648277510068013UL, 9180637584431281687UL, 4539964771860779200UL,
+      10482974169319127550UL, 198276706040285095UL};
+#else
+    constexpr static limb large_power_of_5[] = {
+      4279965485U, 329373468U, 4020270615U, 2137533757U, 4287402176U,
+      1057042919U, 1071430142U, 2440757623U, 381945767U, 46164893U};
+#endif
+    size_t large_length = sizeof(large_power_of_5) / sizeof(limb);
+    limb_span large = limb_span(large_power_of_5, large_length);
+    while (exp >= large_step) {
+      FASTFLOAT_TRY(large_mul(vec, large));
+      exp -= large_step;
+    }
+#ifdef FASTFLOAT_64BIT_LIMB
+    uint32_t small_step = 27;
+    limb max_native = 7450580596923828125UL;
+#else
+    uint32_t small_step = 13;
+    limb max_native = 1220703125U;
+#endif
+    while (exp >= small_step) {
+      FASTFLOAT_TRY(small_mul(vec, max_native));
+      exp -= small_step;
+    }
+    if (exp != 0) {
+      FASTFLOAT_TRY(small_mul(vec, limb(small_power_of_5[exp])));
+    }
+
+    return true;
+  }
+
+  // multiply as if by 10 raised to a power.
+  bool pow10(uint32_t exp) noexcept {
+    FASTFLOAT_TRY(pow5(exp));
+    return pow2(exp);
+  }
+};
+
+} // namespace fast_float
+} // namespace arrow_vendored
+
+#endif
diff --git a/cpp/src/arrow/vendored/fast_float/decimal_to_binary.h b/cpp/src/arrow/vendored/fast_float/decimal_to_binary.h
index 2419de7c03b..8ae481d3238 100644
--- a/cpp/src/arrow/vendored/fast_float/decimal_to_binary.h
+++ b/cpp/src/arrow/vendored/fast_float/decimal_to_binary.h
@@ -7,7 +7,6 @@
 #include <cinttypes>
 #include <cmath>
 #include <cstdint>
-#include <cstdio>
 #include <cstdlib>
 #include <cstring>
 
@@ -21,18 +20,18 @@ namespace fast_float {
 template <int bit_precision>
 fastfloat_really_inline
 value128 compute_product_approximation(int64_t q, uint64_t w) {
-  const int index = 2 * int(q - smallest_power_of_five);
+  const int index = 2 * int(q - powers::smallest_power_of_five);
   // For small values of q, e.g., q in [0,27], the answer is always exact because
   // The line value128 firstproduct = full_multiplication(w, power_of_five_128[index]);
   // gives the exact answer.
-  value128 firstproduct = full_multiplication(w, power_of_five_128[index]);
+  value128 firstproduct = full_multiplication(w, powers::power_of_five_128[index]);
   static_assert((bit_precision >= 0) && (bit_precision <= 64), " precision should  be in (0,64]");
   constexpr uint64_t precision_mask = (bit_precision < 64) ?
                (uint64_t(0xFFFFFFFFFFFFFFFF) >> bit_precision)
                : uint64_t(0xFFFFFFFFFFFFFFFF);
   if((firstproduct.high & precision_mask) == precision_mask) { // could further guard with  (lower + w < lower)
     // regarding the second product, we only need secondproduct.high, but our expectation is that the compiler will optimize this extra work away if needed.
-    value128 secondproduct = full_multiplication(w, power_of_five_128[index + 1]);
+    value128 secondproduct = full_multiplication(w, powers::power_of_five_128[index + 1]);
     firstproduct.low += secondproduct.high;
     if(secondproduct.high > firstproduct.low) {
       firstproduct.high++;
@@ -41,7 +40,7 @@ value128 compute_product_approximation(int64_t q, uint64_t w) {
   return firstproduct;
 }
 
-namespace {
+namespace detail {
 /**
  * For q in (0,350), we have that
  *  f = (((152170 + 65536) * q ) >> 16);
@@ -57,11 +56,34 @@ namespace {
  * where
  *   p = log(5**-q)/log(2) = -q * log(5)/log(2)
  */
-  fastfloat_really_inline int power(int q)  noexcept  {
+  constexpr fastfloat_really_inline int32_t power(int32_t q)  noexcept  {
     return (((152170 + 65536) * q) >> 16) + 63;
   }
-} // namespace
+} // namespace detail
 
+// create an adjusted mantissa, biased by the invalid power2
+// for significant digits already multiplied by 10 ** q.
+template <typename binary>
+fastfloat_really_inline
+adjusted_mantissa compute_error_scaled(int64_t q, uint64_t w, int lz) noexcept  {
+  int hilz = int(w >> 63) ^ 1;
+  adjusted_mantissa answer;
+  answer.mantissa = w << hilz;
+  int bias = binary::mantissa_explicit_bits() - binary::minimum_exponent();
+  answer.power2 = int32_t(detail::power(int32_t(q)) + bias - hilz - lz - 62 + invalid_am_bias);
+  return answer;
+}
+
+// w * 10 ** q, without rounding the representation up.
+// the power2 in the exponent will be adjusted by invalid_am_bias.
+template <typename binary>
+fastfloat_really_inline
+adjusted_mantissa compute_error(int64_t q, uint64_t w)  noexcept  {
+  int lz = leading_zeroes(w);
+  w <<= lz;
+  value128 product = compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
+  return compute_error_scaled<binary>(q, product.high, lz);
+}
 
 // w * 10 ** q
 // The returned value should be a valid ieee64 number that simply need to be packed.
@@ -84,7 +106,7 @@ adjusted_mantissa compute_float(int64_t q, uint64_t w)  noexcept  {
     answer.mantissa = 0;
     return answer;
   }
-  // At this point in time q is in [smallest_power_of_five, largest_power_of_five].
+  // At this point in time q is in [powers::smallest_power_of_five, powers::largest_power_of_five].
 
   // We want the most significant bit of i to be 1. Shift if needed.
   int lz = leading_zeroes(w);
@@ -103,8 +125,7 @@ adjusted_mantissa compute_float(int64_t q, uint64_t w)  noexcept  {
     const bool inside_safe_exponent = (q >= -27) && (q <= 55); // always good because 5**q <2**128 when q>=0, 
     // and otherwise, for q<0, we have 5**-q<2**64 and the 128-bit reciprocal allows for exact computation.
     if(!inside_safe_exponent) {
-      answer.power2 = -1; // This (a negative value) indicates an error condition.
-      return answer;
+      return compute_error_scaled<binary>(q, product.high, lz);
     }
   }
   // The "compute_product_approximation" function can be slightly slower than a branchless approach:
@@ -115,7 +136,7 @@ adjusted_mantissa compute_float(int64_t q, uint64_t w)  noexcept  {
 
   answer.mantissa = product.high >> (upperbit + 64 - binary::mantissa_explicit_bits() - 3);
 
-  answer.power2 = int(power(int(q)) + upperbit - lz - binary::minimum_exponent());
+  answer.power2 = int32_t(detail::power(int32_t(q)) + upperbit - lz - binary::minimum_exponent());
   if (answer.power2 <= 0) { // we have a subnormal?
     // Here have that answer.power2 <= 0 so -answer.power2 >= 0
     if(-answer.power2 + 1 >= 64) { // if we have more than 64 bits below the minimum exponent, you have a zero for sure.
@@ -169,7 +190,6 @@ adjusted_mantissa compute_float(int64_t q, uint64_t w)  noexcept  {
   return answer;
 }
 
-
 } // namespace fast_float
 } // namespace arrow_vendored
 
diff --git a/cpp/src/arrow/vendored/fast_float/digit_comparison.h b/cpp/src/arrow/vendored/fast_float/digit_comparison.h
new file mode 100644
index 00000000000..ba8471a5f05
--- /dev/null
+++ b/cpp/src/arrow/vendored/fast_float/digit_comparison.h
@@ -0,0 +1,409 @@
+#ifndef FASTFLOAT_DIGIT_COMPARISON_H
+#define FASTFLOAT_DIGIT_COMPARISON_H
+
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+
+#include "float_common.h"
+#include "bigint.h"
+#include "ascii_number.h"
+
+namespace arrow_vendored {
+namespace fast_float {
+
+// 1e0 to 1e19
+constexpr static uint64_t powers_of_ten_uint64[] = {
+    1UL, 10UL, 100UL, 1000UL, 10000UL, 100000UL, 1000000UL, 10000000UL, 100000000UL,
+    1000000000UL, 10000000000UL, 100000000000UL, 1000000000000UL, 10000000000000UL,
+    100000000000000UL, 1000000000000000UL, 10000000000000000UL, 100000000000000000UL,
+    1000000000000000000UL, 10000000000000000000UL};
+
+// calculate the exponent, in scientific notation, of the number.
+// this algorithm is not even close to optimized, but it has no practical
+// effect on performance: in order to have a faster algorithm, we'd need
+// to slow down performance for faster algorithms, and this is still fast.
+fastfloat_really_inline int32_t scientific_exponent(parsed_number_string& num) noexcept {
+  uint64_t mantissa = num.mantissa;
+  int32_t exponent = int32_t(num.exponent);
+  while (mantissa >= 10000) {
+    mantissa /= 10000;
+    exponent += 4;
+  }
+  while (mantissa >= 100) {
+    mantissa /= 100;
+    exponent += 2;
+  }
+  while (mantissa >= 10) {
+    mantissa /= 10;
+    exponent += 1;
+  }
+  return exponent;
+}
+
+// this converts a native floating-point number to an extended-precision float.
+template <typename T>
+fastfloat_really_inline adjusted_mantissa to_extended(T value) noexcept {
+  using equiv_uint = typename binary_format<T>::equiv_uint;
+  constexpr equiv_uint exponent_mask = binary_format<T>::exponent_mask();
+  constexpr equiv_uint mantissa_mask = binary_format<T>::mantissa_mask();
+  constexpr equiv_uint hidden_bit_mask = binary_format<T>::hidden_bit_mask();
+
+  adjusted_mantissa am;
+  int32_t bias = binary_format<T>::mantissa_explicit_bits() - binary_format<T>::minimum_exponent();
+  equiv_uint bits;
+  ::memcpy(&bits, &value, sizeof(T));
+  if ((bits & exponent_mask) == 0) {
+    // denormal
+    am.power2 = 1 - bias;
+    am.mantissa = bits & mantissa_mask;
+  } else {
+    // normal
+    am.power2 = int32_t((bits & exponent_mask) >> binary_format<T>::mantissa_explicit_bits());
+    am.power2 -= bias;
+    am.mantissa = (bits & mantissa_mask) | hidden_bit_mask;
+  }
+
+  return am;
+}
+
+// get the extended precision value of the halfway point between b and b+u.
+// we are given a native float that represents b, so we need to adjust it
+// halfway between b and b+u.
+template <typename T>
+fastfloat_really_inline adjusted_mantissa to_extended_halfway(T value) noexcept {
+  adjusted_mantissa am = to_extended(value);
+  am.mantissa <<= 1;
+  am.mantissa += 1;
+  am.power2 -= 1;
+  return am;
+}
+
+// round an extended-precision float to the nearest machine float.
+template <typename T, typename callback>
+fastfloat_really_inline void round(adjusted_mantissa& am, callback cb) noexcept {
+  int32_t mantissa_shift = 64 - binary_format<T>::mantissa_explicit_bits() - 1;
+  if (-am.power2 >= mantissa_shift) {
+    // have a denormal float
+    int32_t shift = -am.power2 + 1;
+    cb(am, std::min(shift, 64));
+    // check for round-up: if rounding-nearest carried us to the hidden bit.
+    am.power2 = (am.mantissa < (uint64_t(1) << binary_format<T>::mantissa_explicit_bits())) ? 0 : 1;
+    return;
+  }
+
+  // have a normal float, use the default shift.
+  cb(am, mantissa_shift);
+
+  // check for carry
+  if (am.mantissa >= (uint64_t(2) << binary_format<T>::mantissa_explicit_bits())) {
+    am.mantissa = (uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
+    am.power2++;
+  }
+
+  // check for infinite: we could have carried to an infinite power
+  am.mantissa &= ~(uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
+  if (am.power2 >= binary_format<T>::infinite_power()) {
+    am.power2 = binary_format<T>::infinite_power();
+    am.mantissa = 0;
+  }
+}
+
+template <typename callback>
+fastfloat_really_inline
+void round_nearest_tie_even(adjusted_mantissa& am, int32_t shift, callback cb) noexcept {
+  uint64_t mask;
+  uint64_t halfway;
+  if (shift == 64) {
+    mask = UINT64_MAX;
+  } else {
+    mask = (uint64_t(1) << shift) - 1;
+  }
+  if (shift == 0) {
+    halfway = 0;
+  } else {
+    halfway = uint64_t(1) << (shift - 1);
+  }
+  uint64_t truncated_bits = am.mantissa & mask;
+  uint64_t is_above = truncated_bits > halfway;
+  uint64_t is_halfway = truncated_bits == halfway;
+
+  // shift digits into position
+  if (shift == 64) {
+    am.mantissa = 0;
+  } else {
+    am.mantissa >>= shift;
+  }
+  am.power2 += shift;
+
+  bool is_odd = (am.mantissa & 1) == 1;
+  am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above));
+}
+
+fastfloat_really_inline void round_down(adjusted_mantissa& am, int32_t shift) noexcept {
+  if (shift == 64) {
+    am.mantissa = 0;
+  } else {
+    am.mantissa >>= shift;
+  }
+  am.power2 += shift;
+}
+
+fastfloat_really_inline void skip_zeros(const char*& first, const char* last) noexcept {
+  uint64_t val;
+  while (std::distance(first, last) >= 8) {
+    ::memcpy(&val, first, sizeof(uint64_t));
+    if (val != 0x3030303030303030) {
+      break;
+    }
+    first += 8;
+  }
+  while (first != last) {
+    if (*first != '0') {
+      break;
+    }
+    first++;
+  }
+}
+
+// determine if any non-zero digits were truncated.
+// all characters must be valid digits.
+fastfloat_really_inline bool is_truncated(const char* first, const char* last) noexcept {
+  // do 8-bit optimizations, can just compare to 8 literal 0s.
+  uint64_t val;
+  while (std::distance(first, last) >= 8) {
+    ::memcpy(&val, first, sizeof(uint64_t));
+    if (val != 0x3030303030303030) {
+      return true;
+    }
+    first += 8;
+  }
+  while (first != last) {
+    if (*first != '0') {
+      return true;
+    }
+    first++;
+  }
+  return false;
+}
+
+fastfloat_really_inline bool is_truncated(byte_span s) noexcept {
+  return is_truncated(s.ptr, s.ptr + s.len());
+}
+
+fastfloat_really_inline
+void parse_eight_digits(const char*& p, limb& value, size_t& counter, size_t& count) noexcept {
+  value = value * 100000000 + parse_eight_digits_unrolled(p);
+  p += 8;
+  counter += 8;
+  count += 8;
+}
+
+fastfloat_really_inline
+void parse_one_digit(const char*& p, limb& value, size_t& counter, size_t& count) noexcept {
+  value = value * 10 + limb(*p - '0');
+  p++;
+  counter++;
+  count++;
+}
+
+fastfloat_really_inline
+void add_native(bigint& big, limb power, limb value) noexcept {
+  big.mul(power);
+  big.add(value);
+}
+
+fastfloat_really_inline void round_up_bigint(bigint& big, size_t& count) noexcept {
+  // need to round-up the digits, but need to avoid rounding
+  // ....9999 to ...10000, which could cause a false halfway point.
+  add_native(big, 10, 1);
+  count++;
+}
+
+// parse the significant digits into a big integer
+inline void parse_mantissa(bigint& result, parsed_number_string& num, size_t max_digits, size_t& digits) noexcept {
+  // try to minimize the number of big integer and scalar multiplication.
+  // therefore, try to parse 8 digits at a time, and multiply by the largest
+  // scalar value (9 or 19 digits) for each step.
+  size_t counter = 0;
+  digits = 0;
+  limb value = 0;
+#ifdef FASTFLOAT_64BIT_LIMB
+  size_t step = 19;
+#else
+  size_t step = 9;
+#endif
+
+  // process all integer digits.
+  const char* p = num.integer.ptr;
+  const char* pend = p + num.integer.len();
+  skip_zeros(p, pend);
+  // process all digits, in increments of step per loop
+  while (p != pend) {
+    while ((std::distance(p, pend) >= 8) && (step - counter >= 8) && (max_digits - digits >= 8)) {
+      parse_eight_digits(p, value, counter, digits);
+    }
+    while (counter < step && p != pend && digits < max_digits) {
+      parse_one_digit(p, value, counter, digits);
+    }
+    if (digits == max_digits) {
+      // add the temporary value, then check if we've truncated any digits
+      add_native(result, limb(powers_of_ten_uint64[counter]), value);
+      bool truncated = is_truncated(p, pend);
+      if (num.fraction.ptr != nullptr) {
+        truncated |= is_truncated(num.fraction);
+      }
+      if (truncated) {
+        round_up_bigint(result, digits);
+      }
+      return;
+    } else {
+      add_native(result, limb(powers_of_ten_uint64[counter]), value);
+      counter = 0;
+      value = 0;
+    }
+  }
+
+  // add our fraction digits, if they're available.
+  if (num.fraction.ptr != nullptr) {
+    p = num.fraction.ptr;
+    pend = p + num.fraction.len();
+    if (digits == 0) {
+      skip_zeros(p, pend);
+    }
+    // process all digits, in increments of step per loop
+    while (p != pend) {
+      while ((std::distance(p, pend) >= 8) && (step - counter >= 8) && (max_digits - digits >= 8)) {
+        parse_eight_digits(p, value, counter, digits);
+      }
+      while (counter < step && p != pend && digits < max_digits) {
+        parse_one_digit(p, value, counter, digits);
+      }
+      if (digits == max_digits) {
+        // add the temporary value, then check if we've truncated any digits
+        add_native(result, limb(powers_of_ten_uint64[counter]), value);
+        bool truncated = is_truncated(p, pend);
+        if (truncated) {
+          round_up_bigint(result, digits);
+        }
+        return;
+      } else {
+        add_native(result, limb(powers_of_ten_uint64[counter]), value);
+        counter = 0;
+        value = 0;
+      }
+    }
+  }
+
+  if (counter != 0) {
+    add_native(result, limb(powers_of_ten_uint64[counter]), value);
+  }
+}
+
+template <typename T>
+inline adjusted_mantissa positive_digit_comp(bigint& bigmant, int32_t exponent) noexcept {
+  FASTFLOAT_ASSERT(bigmant.pow10(uint32_t(exponent)));
+  adjusted_mantissa answer;
+  bool truncated;
+  answer.mantissa = bigmant.hi64(truncated);
+  int bias = binary_format<T>::mantissa_explicit_bits() - binary_format<T>::minimum_exponent();
+  answer.power2 = bigmant.bit_length() - 64 + bias;
+
+  round<T>(answer, [truncated](adjusted_mantissa& a, int32_t shift) {
+    round_nearest_tie_even(a, shift, [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool {
+      return is_above || (is_halfway && truncated) || (is_odd && is_halfway);
+    });
+  });
+
+  return answer;
+}
+
+// the scaling here is quite simple: we have, for the real digits `m * 10^e`,
+// and for the theoretical digits `n * 2^f`. Since `e` is always negative,
+// to scale them identically, we do `n * 2^f * 5^-f`, so we now have `m * 2^e`.
+// we then need to scale by `2^(f- e)`, and then the two significant digits
+// are of the same magnitude.
+template <typename T>
+inline adjusted_mantissa negative_digit_comp(bigint& bigmant, adjusted_mantissa am, int32_t exponent) noexcept {
+  bigint& real_digits = bigmant;
+  int32_t real_exp = exponent;
+
+  // get the value of `b`, rounded down, and get a bigint representation of b+h
+  adjusted_mantissa am_b = am;
+  // gcc7 buf: use a lambda to remove the noexcept qualifier bug with -Wnoexcept-type.
+  round<T>(am_b, [](adjusted_mantissa&a, int32_t shift) { round_down(a, shift); });
+  T b;
+  to_float(false, am_b, b);
+  adjusted_mantissa theor = to_extended_halfway(b);
+  bigint theor_digits(theor.mantissa);
+  int32_t theor_exp = theor.power2;
+
+  // scale real digits and theor digits to be same power.
+  int32_t pow2_exp = theor_exp - real_exp;
+  uint32_t pow5_exp = uint32_t(-real_exp);
+  if (pow5_exp != 0) {
+    FASTFLOAT_ASSERT(theor_digits.pow5(pow5_exp));
+  }
+  if (pow2_exp > 0) {
+    FASTFLOAT_ASSERT(theor_digits.pow2(uint32_t(pow2_exp)));
+  } else if (pow2_exp < 0) {
+    FASTFLOAT_ASSERT(real_digits.pow2(uint32_t(-pow2_exp)));
+  }
+
+  // compare digits, and use it to director rounding
+  int ord = real_digits.compare(theor_digits);
+  adjusted_mantissa answer = am;
+  round<T>(answer, [ord](adjusted_mantissa& a, int32_t shift) {
+    round_nearest_tie_even(a, shift, [ord](bool is_odd, bool _, bool __) -> bool {
+      (void)_;  // not needed, since we've done our comparison
+      (void)__; // not needed, since we've done our comparison
+      if (ord > 0) {
+        return true;
+      } else if (ord < 0) {
+        return false;
+      } else {
+        return is_odd;
+      }
+    });
+  });
+
+  return answer;
+}
+
+// parse the significant digits as a big integer to unambiguously round the
+// the significant digits. here, we are trying to determine how to round
+// an extended float representation close to `b+h`, halfway between `b`
+// (the float rounded-down) and `b+u`, the next positive float. this
+// algorithm is always correct, and uses one of two approaches. when
+// the exponent is positive relative to the significant digits (such as
+// 1234), we create a big-integer representation, get the high 64-bits,
+// determine if any lower bits are truncated, and use that to direct
+// rounding. in case of a negative exponent relative to the significant
+// digits (such as 1.2345), we create a theoretical representation of
+// `b` as a big-integer type, scaled to the same binary exponent as
+// the actual digits. we then compare the big integer representations
+// of both, and use that to direct rounding.
+template <typename T>
+inline adjusted_mantissa digit_comp(parsed_number_string& num, adjusted_mantissa am) noexcept {
+  // remove the invalid exponent bias
+  am.power2 -= invalid_am_bias;
+
+  int32_t sci_exp = scientific_exponent(num);
+  size_t max_digits = binary_format<T>::max_digits();
+  size_t digits = 0;
+  bigint bigmant;
+  parse_mantissa(bigmant, num, max_digits, digits);
+  // can't underflow, since digits is at most max_digits.
+  int32_t exponent = sci_exp + 1 - int32_t(digits);
+  if (exponent >= 0) {
+    return positive_digit_comp<T>(bigmant, exponent);
+  } else {
+    return negative_digit_comp<T>(bigmant, am, exponent);
+  }
+}
+
+} // namespace fast_float
+} // namespace arrow_vendored
+
+#endif
diff --git a/cpp/src/arrow/vendored/fast_float/fast_float.h b/cpp/src/arrow/vendored/fast_float/fast_float.h
index 3e39cac90cf..3b82134ff95 100644
--- a/cpp/src/arrow/vendored/fast_float/fast_float.h
+++ b/cpp/src/arrow/vendored/fast_float/fast_float.h
@@ -18,6 +18,17 @@ struct from_chars_result {
   std::errc ec;
 };
 
+struct parse_options {
+  constexpr explicit parse_options(chars_format fmt = chars_format::general,
+                         char dot = '.')
+    : format(fmt), decimal_point(dot) {}
+
+  /** Which number formats are accepted */
+  chars_format format;
+  /** The character used as decimal point */
+  char decimal_point;
+};
+
 /**
  * This function parses the character sequence [first,last) for a number. It parses floating-point numbers expecting
  * a locale-indepent format equivalent to what is used by std::strtod in the default ("C") locale.
@@ -41,6 +52,13 @@ template<typename T>
 from_chars_result from_chars(const char *first, const char *last,
                              T &value, chars_format fmt = chars_format::general)  noexcept;
 
+/**
+ * Like from_chars, but accepts an `options` argument to govern number parsing.
+ */
+template<typename T>
+from_chars_result from_chars_advanced(const char *first, const char *last,
+                                      T &value, parse_options options)  noexcept;
+
 }
 } // namespace arrow_vendored
 
diff --git a/cpp/src/arrow/vendored/fast_float/fast_table.h b/cpp/src/arrow/vendored/fast_float/fast_table.h
index c1ca1755af9..4861cab3a0d 100644
--- a/cpp/src/arrow/vendored/fast_float/fast_table.h
+++ b/cpp/src/arrow/vendored/fast_float/fast_table.h
@@ -1,5 +1,6 @@
 #ifndef FASTFLOAT_FAST_TABLE_H
 #define FASTFLOAT_FAST_TABLE_H
+
 #include <cstdint>
 
 namespace arrow_vendored {
@@ -29,10 +30,18 @@ namespace fast_float {
  * infinite in binary64 so we never need to worry about powers
  * of 5 greater than 308.
  */
-constexpr int smallest_power_of_five = -342;
-constexpr int largest_power_of_five = 308;
+template <class unused = void>
+struct powers_template {
+
+constexpr static int smallest_power_of_five = binary_format<double>::smallest_power_of_ten();
+constexpr static int largest_power_of_five = binary_format<double>::largest_power_of_ten();
+constexpr static int number_of_entries = 2 * (largest_power_of_five - smallest_power_of_five + 1);
 // Powers of five from 5^-342 all the way to 5^308 rounded toward one.
-const uint64_t power_of_five_128[]= {
+static const uint64_t power_of_five_128[number_of_entries];
+};
+
+template <class unused>
+const uint64_t powers_template<unused>::power_of_five_128[number_of_entries] = {
         0xeef453d6923bd65a,0x113faa2906a13b3f,
         0x9558b4661b6565f8,0x4ac7ca59a424c507,
         0xbaaee17fa23ebf76,0x5d79bcf00d2df649,
@@ -684,6 +693,7 @@ const uint64_t power_of_five_128[]= {
         0xb6472e511c81471d,0xe0133fe4adf8e952,
         0xe3d8f9e563a198e5,0x58180fddd97723a6,
         0x8e679c2f5e44ff8f,0x570f09eaa7ea7648,};
+using powers = powers_template<>;
 
 }
 } // namespace arrow_vendored
diff --git a/cpp/src/arrow/vendored/fast_float/float_common.h b/cpp/src/arrow/vendored/fast_float/float_common.h
index f7b7662b9dd..76241b945f2 100644
--- a/cpp/src/arrow/vendored/fast_float/float_common.h
+++ b/cpp/src/arrow/vendored/fast_float/float_common.h
@@ -4,6 +4,8 @@
 #include <cfloat>
 #include <cstdint>
 #include <cassert>
+#include <cstring>
+#include <type_traits>
 
 #if (defined(__x86_64) || defined(__x86_64__) || defined(_M_X64)   \
        || defined(__amd64) || defined(__aarch64__) || defined(_M_ARM64) \
@@ -13,11 +15,22 @@
        || defined(__EMSCRIPTEN__))
 #define FASTFLOAT_64BIT
 #elif (defined(__i386) || defined(__i386__) || defined(_M_IX86)   \
-     || defined(__arm__)                                        \
+     || defined(__arm__) || defined(_M_ARM)                   \
      || defined(__MINGW32__))
 #define FASTFLOAT_32BIT
 #else
-#error Unknown platform (not 32-bit, not 64-bit?)
+  // Need to check incrementally, since SIZE_MAX is a size_t, avoid overflow.
+  // We can never tell the register width, but the SIZE_MAX is a good approximation.
+  // UINTPTR_MAX and INTPTR_MAX are optional, so avoid them for max portability.
+  #if SIZE_MAX == 0xffff
+    #error Unknown platform (16-bit, unsupported)
+  #elif SIZE_MAX == 0xffffffff
+    #define FASTFLOAT_32BIT
+  #elif SIZE_MAX == 0xffffffffffffffff
+    #define FASTFLOAT_64BIT
+  #else
+    #error Unknown platform (not 32-bit, not 64-bit?)
+  #endif
 #endif
 
 #if ((defined(_WIN32) || defined(_WIN64)) && !defined(__clang__))
@@ -62,6 +75,18 @@
 #define fastfloat_really_inline inline __attribute__((always_inline))
 #endif
 
+#ifndef FASTFLOAT_ASSERT
+#define FASTFLOAT_ASSERT(x)  { if (!(x)) abort(); }
+#endif
+
+#ifndef FASTFLOAT_DEBUG_ASSERT
+#include <cassert>
+#define FASTFLOAT_DEBUG_ASSERT(x) assert(x)
+#endif
+
+// rust style `try!()` macro, or `?` operator
+#define FASTFLOAT_TRY(x) { if (!(x)) return false; }
+
 namespace arrow_vendored {
 namespace fast_float {
 
@@ -79,27 +104,23 @@ inline bool fastfloat_strncasecmp(const char *input1, const char *input2,
 #error "FLT_EVAL_METHOD should be defined, please include cfloat."
 #endif
 
-inline bool is_space(uint8_t c) {
-  static const bool table[] = {
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-  return table[c];
-}
-
-namespace {
-constexpr uint32_t max_digits = 768;
-constexpr uint32_t max_digit_without_overflow = 19;
-constexpr int32_t decimal_point_range = 2047;
-} // namespace
+// a pointer and a length to a contiguous block of memory
+template <typename T>
+struct span {
+  const T* ptr;
+  size_t length;
+  span(const T* _ptr, size_t _length) : ptr(_ptr), length(_length) {}
+  span() : ptr(nullptr), length(0) {}
+
+  constexpr size_t len() const noexcept {
+    return length;
+  }
+
+  const T& operator[](size_t index) const noexcept {
+    FASTFLOAT_DEBUG_ASSERT(index < length);
+    return ptr[index];
+  }
+};
 
 struct value128 {
   uint64_t low;
@@ -135,23 +156,21 @@ fastfloat_really_inline int leading_zeroes(uint64_t input_num) {
 
 #ifdef FASTFLOAT_32BIT
 
-#if (!defined(_WIN32)) || defined(__MINGW32__)
 // slow emulation routine for 32-bit
-fastfloat_really_inline uint64_t __emulu(uint32_t x, uint32_t y) {
+fastfloat_really_inline uint64_t emulu(uint32_t x, uint32_t y) {
     return x * (uint64_t)y;
 }
-#endif
 
 // slow emulation routine for 32-bit
 #if !defined(__MINGW64__)
 fastfloat_really_inline uint64_t _umul128(uint64_t ab, uint64_t cd,
                                           uint64_t *hi) {
-  uint64_t ad = __emulu((uint32_t)(ab >> 32), (uint32_t)cd);
-  uint64_t bd = __emulu((uint32_t)ab, (uint32_t)cd);
-  uint64_t adbc = ad + __emulu((uint32_t)ab, (uint32_t)(cd >> 32));
+  uint64_t ad = emulu((uint32_t)(ab >> 32), (uint32_t)cd);
+  uint64_t bd = emulu((uint32_t)ab, (uint32_t)cd);
+  uint64_t adbc = ad + emulu((uint32_t)ab, (uint32_t)(cd >> 32));
   uint64_t adbc_carry = !!(adbc < ad);
   uint64_t lo = bd + (adbc << 32);
-  *hi = __emulu((uint32_t)(ab >> 32), (uint32_t)(cd >> 32)) + (adbc >> 32) +
+  *hi = emulu((uint32_t)(ab >> 32), (uint32_t)(cd >> 32)) + (adbc >> 32) +
         (adbc_carry << 32) + !!(lo < bd);
   return lo;
 }
@@ -180,10 +199,9 @@ fastfloat_really_inline value128 full_multiplication(uint64_t a,
   return answer;
 }
 
-
 struct adjusted_mantissa {
   uint64_t mantissa{0};
-  int power2{0}; // a negative value indicates an invalid result
+  int32_t power2{0}; // a negative value indicates an invalid result
   adjusted_mantissa() = default;
   bool operator==(const adjusted_mantissa &o) const {
     return mantissa == o.mantissa && power2 == o.power2;
@@ -193,21 +211,8 @@ struct adjusted_mantissa {
   }
 };
 
-struct decimal {
-  uint32_t num_digits{0};
-  int32_t decimal_point{0};
-  bool negative{false};
-  bool truncated{false};
-  uint8_t digits[max_digits];
-  decimal() = default;
-  // Copies are not allowed since this is a fat object.
-  decimal(const decimal &) = delete;
-  // Copies are not allowed since this is a fat object.
-  decimal &operator=(const decimal &) = delete;
-  // Moves are allowed:
-  decimal(decimal &&) = default;
-  decimal &operator=(decimal &&other) = default;
-};
+// Bias so we can get the real exponent with an invalid adjusted_mantissa.
+constexpr static int32_t invalid_am_bias = -0x8000;
 
 constexpr static double powers_of_ten_double[] = {
     1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,  1e10, 1e11,
@@ -216,68 +221,74 @@ constexpr static float powers_of_ten_float[] = {1e0, 1e1, 1e2, 1e3, 1e4, 1e5,
                                                 1e6, 1e7, 1e8, 1e9, 1e10};
 
 template <typename T> struct binary_format {
-  static constexpr int mantissa_explicit_bits();
-  static constexpr int minimum_exponent();
-  static constexpr int infinite_power();
-  static constexpr int sign_index();
-  static constexpr int min_exponent_fast_path();
-  static constexpr int max_exponent_fast_path();
-  static constexpr int max_exponent_round_to_even();
-  static constexpr int min_exponent_round_to_even();
-  static constexpr uint64_t max_mantissa_fast_path();
-  static constexpr int largest_power_of_ten();
-  static constexpr int smallest_power_of_ten();
-  static constexpr T exact_power_of_ten(int64_t power);
+  using equiv_uint = typename std::conditional<sizeof(T) == 4, uint32_t, uint64_t>::type;
+
+  static inline constexpr int mantissa_explicit_bits();
+  static inline constexpr int minimum_exponent();
+  static inline constexpr int infinite_power();
+  static inline constexpr int sign_index();
+  static inline constexpr int min_exponent_fast_path();
+  static inline constexpr int max_exponent_fast_path();
+  static inline constexpr int max_exponent_round_to_even();
+  static inline constexpr int min_exponent_round_to_even();
+  static inline constexpr uint64_t max_mantissa_fast_path();
+  static inline constexpr int largest_power_of_ten();
+  static inline constexpr int smallest_power_of_ten();
+  static inline constexpr T exact_power_of_ten(int64_t power);
+  static inline constexpr size_t max_digits();
+  static inline constexpr equiv_uint exponent_mask();
+  static inline constexpr equiv_uint mantissa_mask();
+  static inline constexpr equiv_uint hidden_bit_mask();
 };
 
-template <> constexpr int binary_format<double>::mantissa_explicit_bits() {
+template <> inline constexpr int binary_format<double>::mantissa_explicit_bits() {
   return 52;
 }
-template <> constexpr int binary_format<float>::mantissa_explicit_bits() {
+template <> inline constexpr int binary_format<float>::mantissa_explicit_bits() {
   return 23;
 }
 
-template <> constexpr int binary_format<double>::max_exponent_round_to_even() {
+template <> inline constexpr int binary_format<double>::max_exponent_round_to_even() {
   return 23;
 }
 
-template <> constexpr int binary_format<float>::max_exponent_round_to_even() {
+template <> inline constexpr int binary_format<float>::max_exponent_round_to_even() {
   return 10;
 }
 
-template <> constexpr int binary_format<double>::min_exponent_round_to_even() {
+template <> inline constexpr int binary_format<double>::min_exponent_round_to_even() {
   return -4;
 }
 
-template <> constexpr int binary_format<float>::min_exponent_round_to_even() {
+template <> inline constexpr int binary_format<float>::min_exponent_round_to_even() {
   return -17;
 }
 
-template <> constexpr int binary_format<double>::minimum_exponent() {
+template <> inline constexpr int binary_format<double>::minimum_exponent() {
   return -1023;
 }
-template <> constexpr int binary_format<float>::minimum_exponent() {
+template <> inline constexpr int binary_format<float>::minimum_exponent() {
   return -127;
 }
 
-template <> constexpr int binary_format<double>::infinite_power() {
+template <> inline constexpr int binary_format<double>::infinite_power() {
   return 0x7FF;
 }
-template <> constexpr int binary_format<float>::infinite_power() {
+template <> inline constexpr int binary_format<float>::infinite_power() {
   return 0xFF;
 }
 
-template <> constexpr int binary_format<double>::sign_index() { return 63; }
-template <> constexpr int binary_format<float>::sign_index() { return 31; }
+template <> inline constexpr int binary_format<double>::sign_index() { return 63; }
+template <> inline constexpr int binary_format<float>::sign_index() { return 31; }
 
-template <> constexpr int binary_format<double>::min_exponent_fast_path() {
+template <> inline constexpr int binary_format<double>::min_exponent_fast_path() {
 #if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
   return 0;
 #else
   return -22;
 #endif
 }
-template <> constexpr int binary_format<float>::min_exponent_fast_path() {
+template <> inline constexpr int binary_format<float>::min_exponent_fast_path() {
 #if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
   return 0;
 #else
@@ -285,61 +296,102 @@ template <> constexpr int binary_format<float>::min_exponent_fast_path() {
 #endif
 }
 
-template <> constexpr int binary_format<double>::max_exponent_fast_path() {
+template <> inline constexpr int binary_format<double>::max_exponent_fast_path() {
   return 22;
 }
-template <> constexpr int binary_format<float>::max_exponent_fast_path() {
+template <> inline constexpr int binary_format<float>::max_exponent_fast_path() {
   return 10;
 }
 
-template <> constexpr uint64_t binary_format<double>::max_mantissa_fast_path() {
+template <> inline constexpr uint64_t binary_format<double>::max_mantissa_fast_path() {
   return uint64_t(2) << mantissa_explicit_bits();
 }
-template <> constexpr uint64_t binary_format<float>::max_mantissa_fast_path() {
+template <> inline constexpr uint64_t binary_format<float>::max_mantissa_fast_path() {
   return uint64_t(2) << mantissa_explicit_bits();
 }
 
 template <>
-constexpr double binary_format<double>::exact_power_of_ten(int64_t power) {
+inline constexpr double binary_format<double>::exact_power_of_ten(int64_t power) {
   return powers_of_ten_double[power];
 }
 template <>
-constexpr float binary_format<float>::exact_power_of_ten(int64_t power) {
+inline constexpr float binary_format<float>::exact_power_of_ten(int64_t power) {
 
   return powers_of_ten_float[power];
 }
 
 
 template <>
-constexpr int binary_format<double>::largest_power_of_ten() {
+inline constexpr int binary_format<double>::largest_power_of_ten() {
   return 308;
 }
 template <>
-constexpr int binary_format<float>::largest_power_of_ten() {
+inline constexpr int binary_format<float>::largest_power_of_ten() {
   return 38;
 }
 
 template <>
-constexpr int binary_format<double>::smallest_power_of_ten() {
+inline constexpr int binary_format<double>::smallest_power_of_ten() {
   return -342;
 }
 template <>
-constexpr int binary_format<float>::smallest_power_of_ten() {
+inline constexpr int binary_format<float>::smallest_power_of_ten() {
   return -65;
 }
 
-} // namespace fast_float
-} // namespace arrow_vendored
+template <> inline constexpr size_t binary_format<double>::max_digits() {
+  return 769;
+}
+template <> inline constexpr size_t binary_format<float>::max_digits() {
+  return 114;
+}
 
-// for convenience:
-template<class OStream>
-inline OStream& operator<<(OStream &out, const arrow_vendored::fast_float::decimal &d) {
-  out << "0.";
-  for (size_t i = 0; i < d.num_digits; i++) {
-    out << int32_t(d.digits[i]);
-  }
-  out << " * 10 ** " << d.decimal_point;
-  return out;
+template <> inline constexpr binary_format<float>::equiv_uint
+    binary_format<float>::exponent_mask() {
+  return 0x7F800000;
+}
+template <> inline constexpr binary_format<double>::equiv_uint
+    binary_format<double>::exponent_mask() {
+  return 0x7FF0000000000000;
+}
+
+template <> inline constexpr binary_format<float>::equiv_uint
+    binary_format<float>::mantissa_mask() {
+  return 0x007FFFFF;
+}
+template <> inline constexpr binary_format<double>::equiv_uint
+    binary_format<double>::mantissa_mask() {
+  return 0x000FFFFFFFFFFFFF;
+}
+
+template <> inline constexpr binary_format<float>::equiv_uint
+    binary_format<float>::hidden_bit_mask() {
+  return 0x00800000;
 }
+template <> inline constexpr binary_format<double>::equiv_uint
+    binary_format<double>::hidden_bit_mask() {
+  return 0x0010000000000000;
+}
+
+template<typename T>
+fastfloat_really_inline void to_float(bool negative, adjusted_mantissa am, T &value) {
+  uint64_t word = am.mantissa;
+  word |= uint64_t(am.power2) << binary_format<T>::mantissa_explicit_bits();
+  word = negative
+  ? word | (uint64_t(1) << binary_format<T>::sign_index()) : word;
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+   if (std::is_same<T, float>::value) {
+     ::memcpy(&value, (char *)&word + 4, sizeof(T)); // extract value at offset 4-7 if float on big-endian
+   } else {
+     ::memcpy(&value, &word, sizeof(T));
+   }
+#else
+   // For little-endian systems:
+   ::memcpy(&value, &word, sizeof(T));
+#endif
+}
+
+} // namespace fast_float
+} // namespace arrow_vendored
 
 #endif
diff --git a/cpp/src/arrow/vendored/fast_float/parse_number.h b/cpp/src/arrow/vendored/fast_float/parse_number.h
index d530f765c84..83dce69af3e 100644
--- a/cpp/src/arrow/vendored/fast_float/parse_number.h
+++ b/cpp/src/arrow/vendored/fast_float/parse_number.h
@@ -1,10 +1,10 @@
 #ifndef FASTFLOAT_PARSE_NUMBER_H
 #define FASTFLOAT_PARSE_NUMBER_H
+
 #include "ascii_number.h"
 #include "decimal_to_binary.h"
-#include "simple_decimal_conversion.h"
+#include "digit_comparison.h"
 
-#include <cassert>
 #include <cmath>
 #include <cstring>
 #include <limits>
@@ -14,7 +14,7 @@ namespace arrow_vendored {
 namespace fast_float {
 
 
-namespace {
+namespace detail {
 /**
  * Special case +inf, -inf, nan, infinity, -infinity.
  * The case comparisons could be made much faster given that we know that the
@@ -26,11 +26,9 @@ from_chars_result parse_infnan(const char *first, const char *last, T &value)  n
   answer.ptr = first;
   answer.ec = std::errc(); // be optimistic
   bool minusSign = false;
-  if (*first == '-') { // assume first < last, so dereference without checks
+  if (*first == '-') { // assume first < last, so dereference without checks; C++17 20.19.3.(7.1) explicitly forbids '+' here
       minusSign = true;
       ++first;
-  } else if( *first == '+' ) { // C++17 20.19.3.7 explicitly forbids '+' here, but anyway
-      ++first;
   }
   if (last - first >= 3) {
     if (fastfloat_strncasecmp(first, "nan", 3)) {
@@ -63,46 +61,30 @@ from_chars_result parse_infnan(const char *first, const char *last, T &value)  n
   return answer;
 }
 
-template<typename T>
-fastfloat_really_inline void to_float(bool negative, adjusted_mantissa am, T &value) {
-  uint64_t word = am.mantissa;
-  word |= uint64_t(am.power2) << binary_format<T>::mantissa_explicit_bits();
-  word = negative
-  ? word | (uint64_t(1) << binary_format<T>::sign_index()) : word;
-#if FASTFLOAT_IS_BIG_ENDIAN == 1
-   if (std::is_same<T, float>::value) {
-     ::memcpy(&value, (char *)&word + 4, sizeof(T)); // extract value at offset 4-7 if float on big-endian
-   } else {
-     ::memcpy(&value, &word, sizeof(T));
-   }
-#else
-   // For little-endian systems:
-   ::memcpy(&value, &word, sizeof(T));
-#endif
-}
-
-} // namespace
-
-
+} // namespace detail
 
 template<typename T>
 from_chars_result from_chars(const char *first, const char *last,
                              T &value, chars_format fmt /*= chars_format::general*/)  noexcept  {
+  return from_chars_advanced(first, last, value, parse_options{fmt});
+}
+
+template<typename T>
+from_chars_result from_chars_advanced(const char *first, const char *last,
+                                      T &value, parse_options options)  noexcept  {
+
   static_assert (std::is_same<T, double>::value || std::is_same<T, float>::value, "only float and double are supported");
 
 
   from_chars_result answer;
-  while ((first != last) && fast_float::is_space(uint8_t(*first))) {
-    first++;
-  }
   if (first == last) {
     answer.ec = std::errc::invalid_argument;
     answer.ptr = first;
     return answer;
   }
-  parsed_number_string pns = parse_number_string(first, last, fmt);
+  parsed_number_string pns = parse_number_string(first, last, options);
   if (!pns.valid) {
-    return parse_infnan(first, last, value);
+    return detail::parse_infnan(first, last, value);
   }
   answer.ec = std::errc(); // be optimistic
   answer.ptr = pns.lastmatch;
@@ -115,14 +97,14 @@ from_chars_result from_chars(const char *first, const char *last,
     return answer;
   }
   adjusted_mantissa am = compute_float<binary_format<T>>(pns.exponent, pns.mantissa);
-  if(pns.too_many_digits) {
+  if(pns.too_many_digits && am.power2 >= 0) {
     if(am != compute_float<binary_format<T>>(pns.exponent, pns.mantissa + 1)) {
-      am.power2 = -1; // value is invalid.
+      am = compute_error<binary_format<T>>(pns.exponent, pns.mantissa);
     }
   }
   // If we called compute_float<binary_format<T>>(pns.exponent, pns.mantissa) and we have an invalid power (am.power2 < 0),
   // then we need to go the long way around again. This is very uncommon.
-  if(am.power2 < 0) { am = parse_long_mantissa<binary_format<T>>(first,last); }
+  if(am.power2 < 0) { am = digit_comp<T>(pns, am); }
   to_float(pns.negative, am, value);
   return answer;
 }
diff --git a/cpp/src/arrow/vendored/fast_float/simple_decimal_conversion.h b/cpp/src/arrow/vendored/fast_float/simple_decimal_conversion.h
index 486724cd9ea..fb6ad2badee 100644
--- a/cpp/src/arrow/vendored/fast_float/simple_decimal_conversion.h
+++ b/cpp/src/arrow/vendored/fast_float/simple_decimal_conversion.h
@@ -20,7 +20,7 @@
 namespace arrow_vendored {
 namespace fast_float {
 
-namespace {
+namespace detail {
 
 // remove all final zeroes
 inline void trim(decimal &h) {
@@ -31,9 +31,9 @@ inline void trim(decimal &h) {
 
 
 
-uint32_t number_of_digits_decimal_left_shift(const decimal &h, uint32_t shift) {
+inline uint32_t number_of_digits_decimal_left_shift(const decimal &h, uint32_t shift) {
   shift &= 63;
-  const static uint16_t number_of_digits_decimal_left_shift_table[65] = {
+  constexpr uint16_t number_of_digits_decimal_left_shift_table[65] = {
     0x0000, 0x0800, 0x0801, 0x0803, 0x1006, 0x1009, 0x100D, 0x1812, 0x1817,
     0x181D, 0x2024, 0x202B, 0x2033, 0x203C, 0x2846, 0x2850, 0x285B, 0x3067,
     0x3073, 0x3080, 0x388E, 0x389C, 0x38AB, 0x38BB, 0x40CC, 0x40DD, 0x40EF,
@@ -48,7 +48,7 @@ uint32_t number_of_digits_decimal_left_shift(const decimal &h, uint32_t shift) {
   uint32_t num_new_digits = x_a >> 11;
   uint32_t pow5_a = 0x7FF & x_a;
   uint32_t pow5_b = 0x7FF & x_b;
-  const static uint8_t
+  constexpr uint8_t
     number_of_digits_decimal_left_shift_table_powers_of_5[0x051C] = {
         5, 2, 5, 1, 2, 5, 6, 2, 5, 3, 1, 2, 5, 1, 5, 6, 2, 5, 7, 8, 1, 2, 5, 3,
         9, 0, 6, 2, 5, 1, 9, 5, 3, 1, 2, 5, 9, 7, 6, 5, 6, 2, 5, 4, 8, 8, 2, 8,
@@ -124,7 +124,7 @@ uint32_t number_of_digits_decimal_left_shift(const decimal &h, uint32_t shift) {
   return num_new_digits;
 }
 
-uint64_t round(decimal &h) {
+inline uint64_t round(decimal &h) {
   if ((h.num_digits == 0) || (h.decimal_point < 0)) {
     return 0;
   } else if (h.decimal_point > 18) {
@@ -151,7 +151,7 @@ uint64_t round(decimal &h) {
 }
 
 // computes h * 2^-shift
-void decimal_left_shift(decimal &h, uint32_t shift) {
+inline void decimal_left_shift(decimal &h, uint32_t shift) {
   if (h.num_digits == 0) {
     return;
   }
@@ -193,7 +193,7 @@ void decimal_left_shift(decimal &h, uint32_t shift) {
 }
 
 // computes h * 2^shift
-void decimal_right_shift(decimal &h, uint32_t shift) {
+inline void decimal_right_shift(decimal &h, uint32_t shift) {
   uint32_t read_index = 0;
   uint32_t write_index = 0;
 
@@ -239,7 +239,7 @@ void decimal_right_shift(decimal &h, uint32_t shift) {
   trim(h);
 }
 
-} // end of anonymous namespace
+} // namespace detail
 
 template <typename binary>
 adjusted_mantissa compute_float(decimal &d) {
@@ -272,17 +272,17 @@ adjusted_mantissa compute_float(decimal &d) {
     answer.mantissa = 0;
     return answer;
   }
-  static const uint32_t max_shift = 60;
-  static const uint32_t num_powers = 19;
-  static const uint8_t powers[19] = {
+  constexpr uint32_t max_shift = 60;
+  constexpr uint32_t num_powers = 19;
+  constexpr uint8_t decimal_powers[19] = {
       0,  3,  6,  9,  13, 16, 19, 23, 26, 29, //
       33, 36, 39, 43, 46, 49, 53, 56, 59,     //
   };
   int32_t exp2 = 0;
   while (d.decimal_point > 0) {
     uint32_t n = uint32_t(d.decimal_point);
-    uint32_t shift = (n < num_powers) ? powers[n] : max_shift;
-    decimal_right_shift(d, shift);
+    uint32_t shift = (n < num_powers) ? decimal_powers[n] : max_shift;
+    detail::decimal_right_shift(d, shift);
     if (d.decimal_point < -decimal_point_range) {
       // should be zero
       answer.power2 = 0;
@@ -301,9 +301,9 @@ adjusted_mantissa compute_float(decimal &d) {
       shift = (d.digits[0] < 2) ? 2 : 1;
     } else {
       uint32_t n = uint32_t(-d.decimal_point);
-      shift = (n < num_powers) ? powers[n] : max_shift;
+      shift = (n < num_powers) ? decimal_powers[n] : max_shift;
     }
-    decimal_left_shift(d, shift);
+    detail::decimal_left_shift(d, shift);
     if (d.decimal_point > decimal_point_range) {
       // we want to get infinity:
       answer.power2 = binary::infinite_power();
@@ -320,7 +320,7 @@ adjusted_mantissa compute_float(decimal &d) {
     if (n > max_shift) {
       n = max_shift;
     }
-    decimal_right_shift(d, n);
+    detail::decimal_right_shift(d, n);
     exp2 += int32_t(n);
   }
   if ((exp2 - minimum_exponent) >= binary::infinite_power()) {
@@ -330,15 +330,15 @@ adjusted_mantissa compute_float(decimal &d) {
   }
 
   const int mantissa_size_in_bits = binary::mantissa_explicit_bits() + 1;
-  decimal_left_shift(d, mantissa_size_in_bits);
+  detail::decimal_left_shift(d, mantissa_size_in_bits);
 
-  uint64_t mantissa = round(d);
+  uint64_t mantissa = detail::round(d);
   // It is possible that we have an overflow, in which case we need
   // to shift back.
   if(mantissa >= (uint64_t(1) << mantissa_size_in_bits)) {
-    decimal_right_shift(d, 1);
+    detail::decimal_right_shift(d, 1);
     exp2 += 1;
-    mantissa = round(d);
+    mantissa = detail::round(d);
     if ((exp2 - minimum_exponent) >= binary::infinite_power()) {
       answer.power2 = binary::infinite_power();
       answer.mantissa = 0;
@@ -352,8 +352,8 @@ adjusted_mantissa compute_float(decimal &d) {
 }
 
 template <typename binary>
-adjusted_mantissa parse_long_mantissa(const char *first, const char* last) {
-    decimal d = parse_decimal(first, last);
+adjusted_mantissa parse_long_mantissa(const char *first, const char* last, parse_options options) {
+    decimal d = parse_decimal(first, last, options);
     return compute_float<binary>(d);
 }
 
diff --git a/cpp/src/arrow/visitor_inline.h b/cpp/src/arrow/visitor_inline.h
index 3321605ae7b..4ede11224bc 100644
--- a/cpp/src/arrow/visitor_inline.h
+++ b/cpp/src/arrow/visitor_inline.h
@@ -173,7 +173,7 @@ struct ArrayDataInlineVisitor<BooleanType> {
     const uint8_t* data = arr.buffers[1]->data();
     return VisitBitBlocks(
         arr.buffers[0], offset, arr.length,
-        [&](int64_t i) { return valid_func(BitUtil::GetBit(data, offset + i)); },
+        [&](int64_t i) { return valid_func(bit_util::GetBit(data, offset + i)); },
         std::forward<NullFunc>(null_func));
   }
 
@@ -184,7 +184,7 @@ struct ArrayDataInlineVisitor<BooleanType> {
     const uint8_t* data = arr.buffers[1]->data();
     VisitBitBlocksVoid(
         arr.buffers[0], offset, arr.length,
-        [&](int64_t i) { valid_func(BitUtil::GetBit(data, offset + i)); },
+        [&](int64_t i) { valid_func(bit_util::GetBit(data, offset + i)); },
         std::forward<NullFunc>(null_func));
   }
 };
@@ -406,7 +406,7 @@ VisitNullBitmapInline(const uint8_t* valid_bits, int64_t valid_bits_offset,
       }
     } else {
       for (int64_t i = 0; i < block.length; ++i) {
-        ARROW_RETURN_NOT_OK(BitUtil::GetBit(valid_bits, offset_position + i)
+        ARROW_RETURN_NOT_OK(bit_util::GetBit(valid_bits, offset_position + i)
                                 ? valid_func()
                                 : null_func());
       }
@@ -439,7 +439,7 @@ VisitNullBitmapInline(const uint8_t* valid_bits, int64_t valid_bits_offset,
       }
     } else {
       for (int64_t i = 0; i < block.length; ++i) {
-        BitUtil::GetBit(valid_bits, offset_position + i) ? valid_func() : null_func();
+        bit_util::GetBit(valid_bits, offset_position + i) ? valid_func() : null_func();
       }
     }
     position += block.length;
diff --git a/cpp/src/gandiva/CMakeLists.txt b/cpp/src/gandiva/CMakeLists.txt
index 654a4a40be1..39eea61ed3f 100644
--- a/cpp/src/gandiva/CMakeLists.txt
+++ b/cpp/src/gandiva/CMakeLists.txt
@@ -79,6 +79,7 @@ set(SRC_FILES
     function_registry_timestamp_arithmetic.cc
     function_signature.cc
     gdv_function_stubs.cc
+    gandiva_object_cache.cc
     hash_utils.cc
     llvm_generator.cc
     llvm_types.cc
diff --git a/cpp/src/gandiva/bitmap_accumulator.cc b/cpp/src/gandiva/bitmap_accumulator.cc
index 8fc66b389f3..13b925e57a1 100644
--- a/cpp/src/gandiva/bitmap_accumulator.cc
+++ b/cpp/src/gandiva/bitmap_accumulator.cc
@@ -28,7 +28,7 @@ void BitMapAccumulator::ComputeResult(uint8_t* dst_bitmap) {
 
   if (all_invalid_) {
     // set all bits to 0.
-    memset(dst_bitmap, 0, arrow::BitUtil::BytesForBits(num_records));
+    memset(dst_bitmap, 0, arrow::bit_util::BytesForBits(num_records));
   } else {
     IntersectBitMaps(dst_bitmap, src_maps_, src_map_offsets_, num_records);
   }
diff --git a/cpp/src/gandiva/bitmap_accumulator_test.cc b/cpp/src/gandiva/bitmap_accumulator_test.cc
index ccffab3e9ff..cb2a76b3d93 100644
--- a/cpp/src/gandiva/bitmap_accumulator_test.cc
+++ b/cpp/src/gandiva/bitmap_accumulator_test.cc
@@ -45,7 +45,7 @@ void TestBitMapAccumulator::ByteWiseIntersectBitMaps(
     uint8_t* dst, const std::vector<uint8_t*>& srcs,
     const std::vector<int64_t>& srcOffsets, int nrecords) {
   if (srcs.empty()) {
-    arrow::BitUtil::SetBitsTo(dst, 0, nrecords, true);
+    arrow::bit_util::SetBitsTo(dst, 0, nrecords, true);
     return;
   }
 
diff --git a/cpp/src/gandiva/cache.cc b/cpp/src/gandiva/cache.cc
index d823a676bc2..c37cbb26171 100644
--- a/cpp/src/gandiva/cache.cc
+++ b/cpp/src/gandiva/cache.cc
@@ -20,13 +20,13 @@
 
 namespace gandiva {
 
-static const int DEFAULT_CACHE_SIZE = 500;
+static const size_t DEFAULT_CACHE_SIZE = 256 * 1024 * 1024;  // 256 MiB
 
-int GetCapacity() {
-  int capacity;
-  const char* env_cache_size = std::getenv("GANDIVA_CACHE_SIZE");
+size_t GetCapacity() {
+  size_t capacity;
+  const char* env_cache_size = std::getenv("GANDIVA_CACHE_SIZE_BYTES");
   if (env_cache_size != nullptr) {
-    capacity = std::atoi(env_cache_size);
+    capacity = std::atol(env_cache_size);
     if (capacity <= 0) {
       ARROW_LOG(WARNING) << "Invalid cache size provided. Using default cache size: "
                          << DEFAULT_CACHE_SIZE;
@@ -39,7 +39,7 @@ int GetCapacity() {
 }
 
 void LogCacheSize(size_t capacity) {
-  ARROW_LOG(INFO) << "Creating gandiva cache with capacity: " << capacity;
+  ARROW_LOG(INFO) << "Creating gandiva cache with capacity of " << capacity << " bytes";
 }
 
 }  // namespace gandiva
diff --git a/cpp/src/gandiva/cache.h b/cpp/src/gandiva/cache.h
index 8d0f75ce36a..5cb92e805e0 100644
--- a/cpp/src/gandiva/cache.h
+++ b/cpp/src/gandiva/cache.h
@@ -27,7 +27,7 @@
 namespace gandiva {
 
 GANDIVA_EXPORT
-int GetCapacity();
+size_t GetCapacity();
 
 GANDIVA_EXPORT
 void LogCacheSize(size_t capacity);
@@ -39,7 +39,7 @@ class Cache {
 
   Cache() : Cache(GetCapacity()) {}
 
-  ValueType GetModule(KeyType cache_key) {
+  ValueType GetObjectCode(KeyType& cache_key) {
     arrow::util::optional<ValueCacheObject<ValueType>> result;
     mtx_.lock();
     result = cache_.get(cache_key);
@@ -47,9 +47,9 @@ class Cache {
     return result != arrow::util::nullopt ? (*result).module : nullptr;
   }
 
-  void PutModule(KeyType cache_key, ValueCacheObject<ValueType> valueCacheObject) {
+  void PutObjectCode(KeyType& cache_key, ValueCacheObject<ValueType>& object_code) {
     mtx_.lock();
-    cache_.insert(cache_key, valueCacheObject);
+    cache_.insert(cache_key, object_code);
     mtx_.unlock();
   }
 
diff --git a/cpp/src/gandiva/engine.h b/cpp/src/gandiva/engine.h
index d26b8aa0ea9..a27f69f53c4 100644
--- a/cpp/src/gandiva/engine.h
+++ b/cpp/src/gandiva/engine.h
@@ -22,10 +22,10 @@
 #include <string>
 #include <vector>
 
-#include "arrow/util/macros.h"
-
 #include "arrow/util/logging.h"
+#include "arrow/util/macros.h"
 #include "gandiva/configuration.h"
+#include "gandiva/gandiva_object_cache.h"
 #include "gandiva/llvm_includes.h"
 #include "gandiva/llvm_types.h"
 #include "gandiva/visibility.h"
@@ -54,6 +54,11 @@ class GANDIVA_EXPORT Engine {
     functions_to_compile_.push_back(fname);
   }
 
+  /// Set LLVM ObjectCache.
+  void SetLLVMObjectCache(GandivaObjectCache& object_cache) {
+    execution_engine_->setObjectCache(&object_cache);
+  }
+
   /// Optimise and compile the module.
   Status FinalizeModule();
 
diff --git a/cpp/src/gandiva/expression_cache_key.h b/cpp/src/gandiva/expression_cache_key.h
new file mode 100644
index 00000000000..2633745ce73
--- /dev/null
+++ b/cpp/src/gandiva/expression_cache_key.h
@@ -0,0 +1,118 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <stddef.h>
+
+#include <thread>
+
+#include "arrow/util/hash_util.h"
+#include "gandiva/arrow.h"
+#include "gandiva/configuration.h"
+#include "gandiva/expression.h"
+#include "gandiva/selection_vector.h"
+#include "gandiva/visibility.h"
+
+namespace gandiva {
+
+class ExpressionCacheKey {
+ public:
+  ExpressionCacheKey(SchemaPtr schema, std::shared_ptr<Configuration> configuration,
+                     ExpressionVector expression_vector, SelectionVector::Mode mode)
+      : schema_(schema), mode_(mode), uniqifier_(0), configuration_(configuration) {
+    static const int kSeedValue = 4;
+    size_t result = kSeedValue;
+    for (auto& expr : expression_vector) {
+      std::string expr_as_string = expr->ToString();
+      expressions_as_strings_.push_back(expr_as_string);
+      arrow::internal::hash_combine(result, expr_as_string);
+      UpdateUniqifier(expr_as_string);
+    }
+    arrow::internal::hash_combine(result, static_cast<size_t>(mode));
+    arrow::internal::hash_combine(result, configuration->Hash());
+    arrow::internal::hash_combine(result, schema_->ToString());
+    arrow::internal::hash_combine(result, uniqifier_);
+    hash_code_ = result;
+  }
+
+  ExpressionCacheKey(SchemaPtr schema, std::shared_ptr<Configuration> configuration,
+                     Expression& expression)
+      : schema_(schema), uniqifier_(0), configuration_(configuration) {
+    static const int kSeedValue = 4;
+    size_t result = kSeedValue;
+    expressions_as_strings_.push_back(expression.ToString());
+    UpdateUniqifier(expression.ToString());
+
+    arrow::internal::hash_combine(result, configuration->Hash());
+    arrow::internal::hash_combine(result, schema_->ToString());
+    arrow::internal::hash_combine(result, uniqifier_);
+    hash_code_ = result;
+  }
+
+  void UpdateUniqifier(const std::string& expr) {
+    if (uniqifier_ == 0) {
+      // caching of expressions with re2 patterns causes lock contention. So, use
+      // multiple instances to reduce contention.
+      if (expr.find(" like(") != std::string::npos) {
+        uniqifier_ = std::hash<std::thread::id>()(std::this_thread::get_id()) % 16;
+      }
+    }
+  }
+
+  size_t Hash() const { return hash_code_; }
+
+  bool operator==(const ExpressionCacheKey& other) const {
+    if (hash_code_ != other.hash_code_) {
+      return false;
+    }
+
+    if (!(schema_->Equals(*other.schema_, true))) {
+      return false;
+    }
+
+    if (configuration_ != other.configuration_) {
+      return false;
+    }
+
+    if (mode_ != other.mode_) {
+      return false;
+    }
+
+    if (expressions_as_strings_ != other.expressions_as_strings_) {
+      return false;
+    }
+
+    if (uniqifier_ != other.uniqifier_) {
+      return false;
+    }
+
+    return true;
+  }
+
+  bool operator!=(const ExpressionCacheKey& other) const { return !(*this == other); }
+
+ private:
+  size_t hash_code_;
+  SchemaPtr schema_;
+  std::vector<std::string> expressions_as_strings_;
+  SelectionVector::Mode mode_;
+  uint32_t uniqifier_;
+  std::shared_ptr<Configuration> configuration_;
+};
+
+}  // namespace gandiva
diff --git a/cpp/src/gandiva/expression_registry.cc b/cpp/src/gandiva/expression_registry.cc
index c3a08fd3a4f..9bff97f5ad2 100644
--- a/cpp/src/gandiva/expression_registry.cc
+++ b/cpp/src/gandiva/expression_registry.cc
@@ -60,8 +60,8 @@ FunctionSignature ExpressionRegistry::FunctionSignatureIterator::operator*() {
   return *func_sig_it_;
 }
 
-ExpressionRegistry::func_sig_iterator_type ExpressionRegistry::FunctionSignatureIterator::
-operator++(int increment) {
+ExpressionRegistry::func_sig_iterator_type
+ExpressionRegistry::FunctionSignatureIterator::operator++(int increment) {
   ++func_sig_it_;
   // point func_sig_it_ to first signature of next nativefunction if func_sig_it_ is
   // pointing to end
diff --git a/cpp/src/gandiva/filter.cc b/cpp/src/gandiva/filter.cc
index 875cc5447f4..1b6c6453ced 100644
--- a/cpp/src/gandiva/filter.cc
+++ b/cpp/src/gandiva/filter.cc
@@ -18,74 +18,18 @@
 #include "gandiva/filter.h"
 
 #include <memory>
-#include <thread>
 #include <utility>
-#include <vector>
-
-#include "arrow/util/hash_util.h"
 
 #include "gandiva/bitmap_accumulator.h"
 #include "gandiva/cache.h"
 #include "gandiva/condition.h"
 #include "gandiva/expr_validator.h"
+#include "gandiva/expression_cache_key.h"
 #include "gandiva/llvm_generator.h"
 #include "gandiva/selection_vector_impl.h"
 
 namespace gandiva {
 
-FilterCacheKey::FilterCacheKey(SchemaPtr schema,
-                               std::shared_ptr<Configuration> configuration,
-                               Expression& expression)
-    : schema_(schema), configuration_(configuration), uniqifier_(0) {
-  static const int kSeedValue = 4;
-  size_t result = kSeedValue;
-  expression_as_string_ = expression.ToString();
-  UpdateUniqifier(expression_as_string_);
-  arrow::internal::hash_combine(result, expression_as_string_);
-  arrow::internal::hash_combine(result, configuration);
-  arrow::internal::hash_combine(result, schema_->ToString());
-  arrow::internal::hash_combine(result, uniqifier_);
-  hash_code_ = result;
-}
-
-bool FilterCacheKey::operator==(const FilterCacheKey& other) const {
-  // arrow schema does not overload equality operators.
-  if (!(schema_->Equals(*other.schema().get(), true))) {
-    return false;
-  }
-
-  if (configuration_ != other.configuration_) {
-    return false;
-  }
-
-  if (expression_as_string_ != other.expression_as_string_) {
-    return false;
-  }
-
-  if (uniqifier_ != other.uniqifier_) {
-    return false;
-  }
-  return true;
-}
-
-std::string FilterCacheKey::ToString() const {
-  std::stringstream ss;
-  // indent, window, indent_size, null_rep and skip new lines.
-  arrow::PrettyPrintOptions options{0, 10, 2, "null", true};
-  DCHECK_OK(PrettyPrint(*schema_.get(), options, &ss));
-
-  ss << "Condition: [" << expression_as_string_ << "]";
-  return ss.str();
-}
-
-void FilterCacheKey::UpdateUniqifier(const std::string& expr) {
-  // caching of expressions with re2 patterns causes lock contention. So, use
-  // multiple instances to reduce contention.
-  if (expr.find(" like(") != std::string::npos) {
-    uniqifier_ = std::hash<std::thread::id>()(std::this_thread::get_id()) % 16;
-  }
-}
-
 Filter::Filter(std::unique_ptr<LLVMGenerator> llvm_generator, SchemaPtr schema,
                std::shared_ptr<Configuration> configuration)
     : llvm_generator_(std::move(llvm_generator)),
@@ -102,14 +46,25 @@ Status Filter::Make(SchemaPtr schema, ConditionPtr condition,
   ARROW_RETURN_IF(configuration == nullptr,
                   Status::Invalid("Configuration cannot be null"));
 
-  static Cache<FilterCacheKey, std::shared_ptr<Filter>> cache;
-  FilterCacheKey cache_key(schema, configuration, *(condition.get()));
-  auto cachedFilter = cache.GetModule(cache_key);
-  if (cachedFilter != nullptr) {
-    *filter = cachedFilter;
-    return Status::OK();
+  std::shared_ptr<Cache<ExpressionCacheKey, std::shared_ptr<llvm::MemoryBuffer>>> cache =
+      LLVMGenerator::GetCache();
+
+  Condition conditionToKey = *(condition.get());
+
+  ExpressionCacheKey cache_key(schema, configuration, conditionToKey);
+
+  bool is_cached = false;
+
+  std::shared_ptr<llvm::MemoryBuffer> prev_cached_obj;
+  prev_cached_obj = cache->GetObjectCode(cache_key);
+
+  // Verify if previous filter obj code was cached
+  if (prev_cached_obj != nullptr) {
+    is_cached = true;
   }
 
+  GandivaObjectCache obj_cache(cache, cache_key);
+
   // Build LLVM generator, and generate code for the specified expression
   std::unique_ptr<LLVMGenerator> llvm_gen;
   ARROW_RETURN_NOT_OK(LLVMGenerator::Make(configuration, &llvm_gen));
@@ -119,18 +74,17 @@ Status Filter::Make(SchemaPtr schema, ConditionPtr condition,
   ExprValidator expr_validator(llvm_gen->types(), schema);
   ARROW_RETURN_NOT_OK(expr_validator.Validate(condition));
 
-  // Start measuring build time
-  auto begin = std::chrono::high_resolution_clock::now();
-  ARROW_RETURN_NOT_OK(llvm_gen->Build({condition}, SelectionVector::Mode::MODE_NONE));
-  // Stop measuring time and calculate the elapsed time
-  auto end = std::chrono::high_resolution_clock::now();
-  auto elapsed =
-      std::chrono::duration_cast<std::chrono::milliseconds>(end - begin).count();
+  // Set the object cache for LLVM
+  llvm_gen->SetLLVMObjectCache(obj_cache);
+
+  ARROW_RETURN_NOT_OK(llvm_gen->Build(
+      {condition},
+      SelectionVector::Mode::MODE_NONE));  // to use when caching only the obj code
 
   // Instantiate the filter with the completely built llvm generator
   *filter = std::make_shared<Filter>(std::move(llvm_gen), schema, configuration);
-  ValueCacheObject<std::shared_ptr<Filter>> value_cache(*filter, elapsed);
-  cache.PutModule(cache_key, value_cache);
+
+  filter->get()->SetBuiltFromCache(is_cached);
 
   return Status::OK();
 }
@@ -168,4 +122,8 @@ Status Filter::Evaluate(const arrow::RecordBatch& batch,
 
 std::string Filter::DumpIR() { return llvm_generator_->DumpIR(); }
 
+void Filter::SetBuiltFromCache(bool flag) { built_from_cache_ = flag; }
+
+bool Filter::GetBuiltFromCache() { return built_from_cache_; }
+
 }  // namespace gandiva
diff --git a/cpp/src/gandiva/filter.h b/cpp/src/gandiva/filter.h
index 70ccd7cf0ce..055bc7b4fce 100644
--- a/cpp/src/gandiva/filter.h
+++ b/cpp/src/gandiva/filter.h
@@ -34,31 +34,6 @@ namespace gandiva {
 
 class LLVMGenerator;
 
-class FilterCacheKey {
- public:
-  FilterCacheKey(SchemaPtr schema, std::shared_ptr<Configuration> configuration,
-                 Expression& expression);
-
-  std::size_t Hash() const { return hash_code_; }
-
-  bool operator==(const FilterCacheKey& other) const;
-
-  bool operator!=(const FilterCacheKey& other) const { return !(*this == other); }
-
-  SchemaPtr schema() const { return schema_; }
-
-  std::string ToString() const;
-
- private:
-  void UpdateUniqifier(const std::string& expr);
-
-  const SchemaPtr schema_;
-  const std::shared_ptr<Configuration> configuration_;
-  std::string expression_as_string_;
-  size_t hash_code_;
-  uint32_t uniqifier_;
-};
-
 /// \brief filter records based on a condition.
 ///
 /// A filter is built for a specific schema and condition. Once the filter is built, it
@@ -103,10 +78,14 @@ class GANDIVA_EXPORT Filter {
 
   std::string DumpIR();
 
+  void SetBuiltFromCache(bool flag);
+  bool GetBuiltFromCache();
+
  private:
   std::unique_ptr<LLVMGenerator> llvm_generator_;
   SchemaPtr schema_;
   std::shared_ptr<Configuration> configuration_;
+  bool built_from_cache_;
 };
 
 }  // namespace gandiva
diff --git a/cpp/src/gandiva/function_registry_arithmetic.cc b/cpp/src/gandiva/function_registry_arithmetic.cc
index d0135d793d5..4dc478fe8f6 100644
--- a/cpp/src/gandiva/function_registry_arithmetic.cc
+++ b/cpp/src/gandiva/function_registry_arithmetic.cc
@@ -37,6 +37,28 @@ namespace gandiva {
 
 #define UNARY_CAST_TO_INT64(type) UNARY_SAFE_NULL_IF_NULL(castBIGINT, {}, type, int64)
 
+#define MULTIPLE_SAFE_NULL_IF_NULL(NAME, ALIASES, TYPE)                                 \
+  NativeFunction(#NAME, std::vector<std::string> ALIASES,                               \
+                 DataTypeVector{TYPE(), TYPE()}, TYPE(), kResultNullIfNull,             \
+                 ARROW_STRINGIFY(NAME##_##TYPE##_##TYPE)),                              \
+      NativeFunction(#NAME, std::vector<std::string> ALIASES,                           \
+                     DataTypeVector{TYPE(), TYPE(), TYPE()}, TYPE(), kResultNullIfNull, \
+                     ARROW_STRINGIFY(NAME##_##TYPE##_##TYPE##_##TYPE)),                 \
+      NativeFunction(#NAME, std::vector<std::string> ALIASES,                           \
+                     DataTypeVector{TYPE(), TYPE(), TYPE(), TYPE()}, TYPE(),            \
+                     kResultNullIfNull,                                                 \
+                     ARROW_STRINGIFY(NAME##_##TYPE##_##TYPE##_##TYPE##_##TYPE)),        \
+      NativeFunction(                                                                   \
+          #NAME, std::vector<std::string> ALIASES,                                      \
+          DataTypeVector{TYPE(), TYPE(), TYPE(), TYPE(), TYPE()}, TYPE(),               \
+          kResultNullIfNull,                                                            \
+          ARROW_STRINGIFY(NAME##_##TYPE##_##TYPE##_##TYPE##_##TYPE##_##TYPE)),          \
+      NativeFunction(                                                                   \
+          #NAME, std::vector<std::string> ALIASES,                                      \
+          DataTypeVector{TYPE(), TYPE(), TYPE(), TYPE(), TYPE(), TYPE()}, TYPE(),       \
+          kResultNullIfNull,                                                            \
+          ARROW_STRINGIFY(NAME##_##TYPE##_##TYPE##_##TYPE##_##TYPE##_##TYPE##_##TYPE))
+
 std::vector<NativeFunction> GetArithmeticFunctionRegistry() {
   static std::vector<NativeFunction> arithmetic_fn_registry_ = {
       UNARY_SAFE_NULL_IF_NULL(not, {}, boolean, boolean),
@@ -101,6 +123,28 @@ std::vector<NativeFunction> GetArithmeticFunctionRegistry() {
       UNARY_SAFE_NULL_IF_NULL(bitwise_not, {}, int32, int32),
       UNARY_SAFE_NULL_IF_NULL(bitwise_not, {}, int64, int64),
 
+      // is true, is not false, is false
+      UNARY_SAFE_NULL_IF_NULL(istrue, ({"is true", "isnotfalse", "is not false"}),
+                              boolean, boolean),
+      UNARY_SAFE_NULL_IF_NULL(isfalse, ({"is false", "isnottrue", "is not true"}),
+                              boolean, boolean),
+      UNARY_SAFE_NULL_IF_NULL(istrue, ({"is true", "isnotfalse", "is not false"}), int32,
+                              boolean),
+      UNARY_SAFE_NULL_IF_NULL(isfalse, ({"is false", "isnottrue", "is not true"}), int32,
+                              boolean),
+      UNARY_SAFE_NULL_IF_NULL(istrue, ({"is true", "isnotfalse", "is not false"}), int64,
+                              boolean),
+      UNARY_SAFE_NULL_IF_NULL(isfalse, ({"is false", "isnottrue", "is not true"}), int64,
+                              boolean),
+      UNARY_SAFE_NULL_IF_NULL(istrue, ({"is true", "isnotfalse", "is not false"}),
+                              float32, boolean),
+      UNARY_SAFE_NULL_IF_NULL(isfalse, ({"is false", "isnottrue", "is not true"}),
+                              float32, boolean),
+      UNARY_SAFE_NULL_IF_NULL(istrue, ({"is true", "isnotfalse", "is not false"}),
+                              float64, boolean),
+      UNARY_SAFE_NULL_IF_NULL(isfalse, ({"is false", "isnottrue", "is not true"}),
+                              float64, boolean),
+
       // round functions
       UNARY_SAFE_NULL_IF_NULL(round, {}, float32, float32),
       UNARY_SAFE_NULL_IF_NULL(round, {}, float64, float64),
@@ -122,6 +166,8 @@ std::vector<NativeFunction> GetArithmeticFunctionRegistry() {
       BINARY_RELATIONAL_BOOL_DATE_FN(less_than_or_equal_to, {}),
       BINARY_RELATIONAL_BOOL_DATE_FN(greater_than, {}),
       BINARY_RELATIONAL_BOOL_DATE_FN(greater_than_or_equal_to, {}),
+      BASE_NUMERIC_TYPES(MULTIPLE_SAFE_NULL_IF_NULL, greatest, {}),
+      BASE_NUMERIC_TYPES(MULTIPLE_SAFE_NULL_IF_NULL, least, {}),
 
       // binary representation of integer values
       UNARY_UNSAFE_NULL_IF_NULL(bin, {}, int32, utf8),
diff --git a/cpp/src/gandiva/function_registry_common.h b/cpp/src/gandiva/function_registry_common.h
index 2c46a2dcc04..5ce21125abe 100644
--- a/cpp/src/gandiva/function_registry_common.h
+++ b/cpp/src/gandiva/function_registry_common.h
@@ -154,6 +154,16 @@ typedef std::unordered_map<const FunctionSignature*, const NativeFunction*, KeyH
                  DataTypeVector{TYPE(), TYPE()}, boolean(), kResultNullNever, \
                  ARROW_STRINGIFY(NAME##_##TYPE##_##TYPE))
 
+// Binary functions that :
+// - NULL handling is of type NULL_NEVER
+//
+// The pre-compiled fn name includes the base name & input type names,
+// eg. nvl_int32_int32
+#define BINARY_SAFE_NULL_NEVER(NAME, ALIASES, TYPE)                        \
+  NativeFunction(#NAME, std::vector<std::string> ALIASES,                  \
+                 DataTypeVector{TYPE(), TYPE()}, TYPE(), kResultNullNever, \
+                 ARROW_STRINGIFY(NAME##_##TYPE##_##TYPE))
+
 // Extract functions (used with data/time types) that :
 // - NULL handling is of type NULL_IF_NULL
 //
diff --git a/cpp/src/gandiva/function_registry_datetime.cc b/cpp/src/gandiva/function_registry_datetime.cc
index b8d2e7b6c7d..54e2fa87c5c 100644
--- a/cpp/src/gandiva/function_registry_datetime.cc
+++ b/cpp/src/gandiva/function_registry_datetime.cc
@@ -46,6 +46,8 @@ namespace gandiva {
 
 std::vector<NativeFunction> GetDateTimeFunctionRegistry() {
   static std::vector<NativeFunction> date_time_fn_registry_ = {
+      UNARY_SAFE_NULL_NEVER_BOOL(isnull, {}, day_time_interval),
+      UNARY_SAFE_NULL_NEVER_BOOL(isnull, {}, month_interval),
       DATE_EXTRACTION_TRUNCATION_FNS(EXTRACT_SAFE_NULL_IF_NULL, extract),
       DATE_EXTRACTION_TRUNCATION_FNS(TRUNCATE_SAFE_NULL_IF_NULL, date_trunc_),
 
diff --git a/cpp/src/gandiva/function_registry_math_ops.cc b/cpp/src/gandiva/function_registry_math_ops.cc
index 49afd40039b..87c7aed2ad9 100644
--- a/cpp/src/gandiva/function_registry_math_ops.cc
+++ b/cpp/src/gandiva/function_registry_math_ops.cc
@@ -50,6 +50,15 @@ namespace gandiva {
 #define BINARY_SAFE_NULL_NEVER_BOOL_FN(name, ALIASES) \
   NUMERIC_BOOL_DATE_TYPES(BINARY_SAFE_NULL_NEVER_BOOL, name, ALIASES)
 
+#define BINARY_SYMMETRIC_SAFE_NULL_NEVER_FN(name, ALIASES) \
+  BINARY_SAFE_NULL_NEVER(name, ALIASES, int32),            \
+      BINARY_SAFE_NULL_NEVER(name, ALIASES, int64),        \
+      BINARY_SAFE_NULL_NEVER(name, ALIASES, uint32),       \
+      BINARY_SAFE_NULL_NEVER(name, ALIASES, uint64),       \
+      BINARY_SAFE_NULL_NEVER(name, ALIASES, float32),      \
+      BINARY_SAFE_NULL_NEVER(name, ALIASES, float64),      \
+      BINARY_SAFE_NULL_NEVER(name, ALIASES, boolean)
+
 std::vector<NativeFunction> GetMathOpsFunctionRegistry() {
   static std::vector<NativeFunction> math_fn_registry_ = {
       MATH_UNARY_OPS(cbrt, {}), MATH_UNARY_OPS(exp, {}), MATH_UNARY_OPS(log, {}),
@@ -67,6 +76,9 @@ std::vector<NativeFunction> GetMathOpsFunctionRegistry() {
       BINARY_SAFE_NULL_NEVER_BOOL_FN(is_distinct_from, {}),
       BINARY_SAFE_NULL_NEVER_BOOL_FN(is_not_distinct_from, {}),
 
+      UNARY_UNSAFE_NULL_IF_NULL(factorial, {}, int32, int64),
+      UNARY_UNSAFE_NULL_IF_NULL(factorial, {}, int64, int64),
+
       // trigonometry functions
       MATH_UNARY_OPS(sin, {}), MATH_UNARY_OPS(cos, {}), MATH_UNARY_OPS(asin, {}),
       MATH_UNARY_OPS(acos, {}), MATH_UNARY_OPS(tan, {}), MATH_UNARY_OPS(atan, {}),
@@ -83,6 +95,7 @@ std::vector<NativeFunction> GetMathOpsFunctionRegistry() {
       BINARY_GENERIC_SAFE_NULL_IF_NULL(round, {}, decimal128, int32, decimal128),
       BINARY_GENERIC_SAFE_NULL_IF_NULL(truncate, {"trunc"}, decimal128, int32,
                                        decimal128),
+      BINARY_SYMMETRIC_SAFE_NULL_NEVER_FN(nvl, {}),
 
       NativeFunction("truncate", {"trunc"}, DataTypeVector{int64(), int32()}, int64(),
                      kResultNullIfNull, "truncate_int64_int32"),
diff --git a/cpp/src/gandiva/function_registry_string.cc b/cpp/src/gandiva/function_registry_string.cc
index f9a48159b93..4c8a16b049f 100644
--- a/cpp/src/gandiva/function_registry_string.cc
+++ b/cpp/src/gandiva/function_registry_string.cc
@@ -451,6 +451,10 @@ std::vector<NativeFunction> GetStringFunctionRegistry() {
                      kResultNullIfNull, "gdv_fn_castVARBINARY_float64_int64",
                      NativeFunction::kNeedsContext | NativeFunction::kCanReturnErrors),
 
+      NativeFunction("levenshtein", {}, DataTypeVector{utf8(), utf8()}, int32(),
+                     kResultNullIfNull, "levenshtein",
+                     NativeFunction::kNeedsContext | NativeFunction::kCanReturnErrors),
+
       NativeFunction("to_hex", {"hex"}, DataTypeVector{binary()}, utf8(),
                      kResultNullIfNull, "to_hex_binary", NativeFunction::kNeedsContext),
 
diff --git a/cpp/src/gandiva/gandiva_object_cache.cc b/cpp/src/gandiva/gandiva_object_cache.cc
new file mode 100644
index 00000000000..07449200cf8
--- /dev/null
+++ b/cpp/src/gandiva/gandiva_object_cache.cc
@@ -0,0 +1,62 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "gandiva/gandiva_object_cache.h"
+
+namespace gandiva {
+
+GandivaObjectCache::GandivaObjectCache(
+    std::shared_ptr<Cache<ExpressionCacheKey, std::shared_ptr<llvm::MemoryBuffer>>>&
+        cache,
+    ExpressionCacheKey key)
+    : cache_key_(key) {
+  cache_ = cache;
+  // Start measuring code gen time
+  begin_time_ = std::chrono::high_resolution_clock::now();
+}
+
+void GandivaObjectCache::notifyObjectCompiled(const llvm::Module* M,
+                                              llvm::MemoryBufferRef Obj) {
+  // Stop measuring time and  calculate the elapsed time to compile the object code
+  auto end_time = std::chrono::high_resolution_clock::now();
+  auto elapsed_time =
+      std::chrono::duration_cast<std::chrono::milliseconds>(end_time - begin_time_)
+          .count();
+
+  std::unique_ptr<llvm::MemoryBuffer> obj_buffer =
+      llvm::MemoryBuffer::getMemBufferCopy(Obj.getBuffer(), Obj.getBufferIdentifier());
+  std::shared_ptr<llvm::MemoryBuffer> obj_code = std::move(obj_buffer);
+
+  ValueCacheObject<std::shared_ptr<llvm::MemoryBuffer>> value_cache(
+      obj_code, elapsed_time, obj_code->getBufferSize());
+
+  cache_->PutObjectCode(cache_key_, value_cache);
+}
+
+std::unique_ptr<llvm::MemoryBuffer> GandivaObjectCache::getObject(const llvm::Module* M) {
+  std::shared_ptr<llvm::MemoryBuffer> cached_obj = cache_->GetObjectCode(cache_key_);
+  if (cached_obj != nullptr) {
+    std::unique_ptr<llvm::MemoryBuffer> cached_buffer = cached_obj->getMemBufferCopy(
+        cached_obj->getBuffer(), cached_obj->getBufferIdentifier());
+    ARROW_LOG(INFO) << "[INFO][CACHE-LOG]: An object code was found on cache.";
+    return cached_buffer;
+  }
+  ARROW_LOG(INFO) << "[INFO][CACHE-LOG]: No object code was found on cache.";
+  return nullptr;
+}
+
+}  // namespace gandiva
diff --git a/cpp/src/gandiva/gandiva_object_cache.h b/cpp/src/gandiva/gandiva_object_cache.h
new file mode 100644
index 00000000000..1d4265d23e2
--- /dev/null
+++ b/cpp/src/gandiva/gandiva_object_cache.h
@@ -0,0 +1,57 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4244)
+#pragma warning(disable : 4141)
+#pragma warning(disable : 4146)
+#pragma warning(disable : 4267)
+#pragma warning(disable : 4624)
+#endif
+
+#include <llvm/ExecutionEngine/ObjectCache.h>
+#include <llvm/Support/MemoryBuffer.h>
+
+#include <chrono>
+
+#include "gandiva/cache.h"
+#include "gandiva/expression_cache_key.h"
+
+namespace gandiva {
+/// Class that enables the LLVM to use a custom rule to deal with the object code.
+class GandivaObjectCache : public llvm::ObjectCache {
+ public:
+  explicit GandivaObjectCache(
+      std::shared_ptr<Cache<ExpressionCacheKey, std::shared_ptr<llvm::MemoryBuffer>>>&
+          cache,
+      ExpressionCacheKey key);
+
+  ~GandivaObjectCache() {}
+
+  void notifyObjectCompiled(const llvm::Module* M, llvm::MemoryBufferRef Obj);
+
+  std::unique_ptr<llvm::MemoryBuffer> getObject(const llvm::Module* M);
+
+ private:
+  ExpressionCacheKey cache_key_;
+  std::shared_ptr<Cache<ExpressionCacheKey, std::shared_ptr<llvm::MemoryBuffer>>> cache_;
+  std::chrono::high_resolution_clock::time_point begin_time_;
+};
+}  // namespace gandiva
diff --git a/cpp/src/gandiva/greedy_dual_size_cache.h b/cpp/src/gandiva/greedy_dual_size_cache.h
index cb5c38e075c..b06bdf34661 100644
--- a/cpp/src/gandiva/greedy_dual_size_cache.h
+++ b/cpp/src/gandiva/greedy_dual_size_cache.h
@@ -23,6 +23,7 @@
 #include <unordered_map>
 #include <utility>
 
+#include "arrow/util/logging.h"
 #include "arrow/util/optional.h"
 
 // modified cache to support evict policy using the GreedyDual-Size algorithm.
@@ -31,9 +32,11 @@ namespace gandiva {
 template <typename ValueType>
 class ValueCacheObject {
  public:
-  ValueCacheObject(ValueType module, uint64_t cost) : module(module), cost(cost) {}
+  ValueCacheObject(ValueType module, uint64_t cost, size_t size)
+      : module(module), cost(cost), size(size) {}
   ValueType module;
   uint64_t cost;
+  size_t size;
   bool operator<(const ValueCacheObject& other) const { return cost < other.cost; }
 };
 
@@ -84,11 +87,14 @@ class GreedyDualSizeCache {
 
   ~GreedyDualSizeCache() = default;
 
-  size_t size() const { return map_.size(); }
+  size_t size() const { return size_; }
 
   size_t capacity() const { return capacity_; }
 
-  bool empty() const { return map_.empty(); }
+  bool empty() {
+    size_ = 0;
+    return map_.empty();
+  }
 
   bool contains(const Key& key) { return map_.find(key) != map_.end(); }
 
@@ -107,6 +113,7 @@ class GreedyDualSizeCache {
           priority_set_.insert(PriorityItem(value.cost + inflation_, value.cost, key));
       // save on map the value and the priority item iterator position
       map_.emplace(key, std::make_pair(value, item.first));
+      size_ += value.size;
     }
   }
 
@@ -142,6 +149,8 @@ class GreedyDualSizeCache {
     typename std::set<PriorityItem>::iterator i = priority_set_.begin();
     // update the inflation cost related to the evicted item
     inflation_ = (*i).actual_priority;
+    size_t size_to_decrease = map_.find((*i).cache_key)->second.first.size;
+    size_ -= size_to_decrease;
     map_.erase((*i).cache_key);
     priority_set_.erase(i);
   }
@@ -150,5 +159,6 @@ class GreedyDualSizeCache {
   std::set<PriorityItem> priority_set_;
   uint64_t inflation_;
   size_t capacity_;
+  size_t size_ = 0;
 };
 }  // namespace gandiva
diff --git a/cpp/src/gandiva/greedy_dual_size_cache_test.cc b/cpp/src/gandiva/greedy_dual_size_cache_test.cc
index 3c72eef7092..989941f1bbf 100644
--- a/cpp/src/gandiva/greedy_dual_size_cache_test.cc
+++ b/cpp/src/gandiva/greedy_dual_size_cache_test.cc
@@ -46,12 +46,12 @@ class TestGreedyDualSizeCache : public ::testing::Test {
 
 TEST_F(TestGreedyDualSizeCache, TestEvict) {
   // check if the cache is evicting the items with low priority on cache
-  cache_.insert(GreedyDualSizeCacheKey(1), ValueCacheObject<std::string>("1", 1));
-  cache_.insert(GreedyDualSizeCacheKey(2), ValueCacheObject<std::string>("2", 10));
-  cache_.insert(GreedyDualSizeCacheKey(3), ValueCacheObject<std::string>("3", 20));
-  cache_.insert(GreedyDualSizeCacheKey(4), ValueCacheObject<std::string>("4", 15));
-  cache_.insert(GreedyDualSizeCacheKey(1), ValueCacheObject<std::string>("5", 1));
-  ASSERT_EQ(2, cache_.size());
+  cache_.insert(GreedyDualSizeCacheKey(1), ValueCacheObject<std::string>("1", 1, 1));
+  cache_.insert(GreedyDualSizeCacheKey(2), ValueCacheObject<std::string>("2", 10, 10));
+  cache_.insert(GreedyDualSizeCacheKey(3), ValueCacheObject<std::string>("3", 20, 20));
+  cache_.insert(GreedyDualSizeCacheKey(4), ValueCacheObject<std::string>("4", 15, 15));
+  cache_.insert(GreedyDualSizeCacheKey(1), ValueCacheObject<std::string>("5", 1, 1));
+  ASSERT_EQ(16, cache_.size());
   // we check initially the values that won't be on the cache, since the get operation
   // may affect the entity costs, which is not the purpose of this test
   ASSERT_EQ(cache_.get(GreedyDualSizeCacheKey(2)), arrow::util::nullopt);
@@ -62,9 +62,9 @@ TEST_F(TestGreedyDualSizeCache, TestEvict) {
 
 TEST_F(TestGreedyDualSizeCache, TestGreedyDualSizeBehavior) {
   // insert 1 and 3 evicting 2 (this eviction will increase the inflation cost by 20)
-  cache_.insert(GreedyDualSizeCacheKey(1), ValueCacheObject<std::string>("1", 40));
-  cache_.insert(GreedyDualSizeCacheKey(2), ValueCacheObject<std::string>("2", 20));
-  cache_.insert(GreedyDualSizeCacheKey(3), ValueCacheObject<std::string>("3", 30));
+  cache_.insert(GreedyDualSizeCacheKey(1), ValueCacheObject<std::string>("1", 40, 40));
+  cache_.insert(GreedyDualSizeCacheKey(2), ValueCacheObject<std::string>("2", 20, 20));
+  cache_.insert(GreedyDualSizeCacheKey(3), ValueCacheObject<std::string>("3", 30, 30));
 
   // when accessing key 3, its actual cost will be increased by the inflation, so in the
   // next eviction, the key 1 will be evicted, since the key 1 actual cost (original(40))
@@ -72,17 +72,16 @@ TEST_F(TestGreedyDualSizeCache, TestGreedyDualSizeBehavior) {
   ASSERT_EQ(cache_.get(GreedyDualSizeCacheKey(3))->module, "3");
 
   // try to insert key 2 and expect the eviction of key 1
-  cache_.insert(GreedyDualSizeCacheKey(2), ValueCacheObject<std::string>("2", 20));
+  cache_.insert(GreedyDualSizeCacheKey(2), ValueCacheObject<std::string>("2", 20, 20));
   ASSERT_EQ(cache_.get(GreedyDualSizeCacheKey(1)), arrow::util::nullopt);
 
   // when accessing key 2, its original cost should be increased by inflation, so when
   // inserting the key 1 again, now the key 3 should be evicted
   ASSERT_EQ(cache_.get(GreedyDualSizeCacheKey(2))->module, "2");
-  cache_.insert(GreedyDualSizeCacheKey(1), ValueCacheObject<std::string>("1", 20));
+  cache_.insert(GreedyDualSizeCacheKey(1), ValueCacheObject<std::string>("1", 20, 20));
 
   ASSERT_EQ(cache_.get(GreedyDualSizeCacheKey(1))->module, "1");
-  ASSERT_EQ(cache_.get(GreedyDualSizeCacheKey(2))->module, "2");
   ASSERT_EQ(cache_.get(GreedyDualSizeCacheKey(3)), arrow::util::nullopt);
-  ASSERT_EQ(2, cache_.size());
+  ASSERT_EQ(20, cache_.size());
 }
 }  // namespace gandiva
diff --git a/cpp/src/gandiva/llvm_generator.cc b/cpp/src/gandiva/llvm_generator.cc
index 0129e52784f..894910df717 100644
--- a/cpp/src/gandiva/llvm_generator.cc
+++ b/cpp/src/gandiva/llvm_generator.cc
@@ -29,6 +29,7 @@
 #include "gandiva/dex.h"
 #include "gandiva/expr_decomposer.h"
 #include "gandiva/expression.h"
+#include "gandiva/gandiva_object_cache.h"
 #include "gandiva/lvalue.h"
 
 namespace gandiva {
@@ -50,6 +51,15 @@ Status LLVMGenerator::Make(std::shared_ptr<Configuration> config,
   return Status::OK();
 }
 
+std::shared_ptr<Cache<ExpressionCacheKey, std::shared_ptr<llvm::MemoryBuffer>>>
+LLVMGenerator::GetCache() {
+  static std::shared_ptr<Cache<ExpressionCacheKey, std::shared_ptr<llvm::MemoryBuffer>>>
+      shared_cache = std::make_shared<
+          Cache<ExpressionCacheKey, std::shared_ptr<llvm::MemoryBuffer>>>();
+
+  return shared_cache;
+}
+
 Status LLVMGenerator::Add(const ExpressionPtr expr, const FieldDescriptorPtr output) {
   int idx = static_cast<int>(compiled_exprs_.size());
   // decompose the expression to separate out value and validities.
@@ -68,9 +78,15 @@ Status LLVMGenerator::Add(const ExpressionPtr expr, const FieldDescriptorPtr out
   return Status::OK();
 }
 
-/// Build and optimise module for projection expression.
+void LLVMGenerator::SetLLVMObjectCache(GandivaObjectCache& object_cache) {
+  engine_->SetLLVMObjectCache(object_cache);
+}
+
+/// \brief Build the code for the expression trees for default mode with a LLVM
+/// ObjectCache. Each element in the vector represents an expression tree
 Status LLVMGenerator::Build(const ExpressionVector& exprs, SelectionVector::Mode mode) {
   selection_vector_mode_ = mode;
+
   for (auto& expr : exprs) {
     auto output = annotator_.AddOutputFieldDescriptor(expr->result());
     ARROW_RETURN_NOT_OK(Add(expr, output));
@@ -89,6 +105,12 @@ Status LLVMGenerator::Build(const ExpressionVector& exprs, SelectionVector::Mode
   return Status::OK();
 }
 
+/// \brief Build the code for the expression trees for default mode. Each
+/// element in the vector represents an expression tree
+Status LLVMGenerator::Build(const ExpressionVector& exprs) {
+  return Build(exprs, SelectionVector::Mode::MODE_NONE);
+}
+
 /// Execute the compiled module against the provided vectors.
 Status LLVMGenerator::Execute(const arrow::RecordBatch& record_batch,
                               const ArrayDataVector& output_vector) {
@@ -468,10 +490,10 @@ void LLVMGenerator::ComputeBitMapsForExpr(const CompiledExpr& compiled_expr,
 
     auto num_out_records = selection_vector->GetNumSlots();
     // the memset isn't required, doing it just for valgrind.
-    memset(dst_bitmap, 0, arrow::BitUtil::BytesForBits(num_out_records));
+    memset(dst_bitmap, 0, arrow::bit_util::BytesForBits(num_out_records));
     for (auto i = 0; i < num_out_records; ++i) {
-      auto bit = arrow::BitUtil::GetBit(temp_bitmap, selection_vector->GetIndex(i));
-      arrow::BitUtil::SetBitTo(dst_bitmap, i, bit);
+      auto bit = arrow::bit_util::GetBit(temp_bitmap, selection_vector->GetIndex(i));
+      arrow::bit_util::SetBitTo(dst_bitmap, i, bit);
     }
   }
 }
diff --git a/cpp/src/gandiva/llvm_generator.h b/cpp/src/gandiva/llvm_generator.h
index ff6d846024c..97f55eae730 100644
--- a/cpp/src/gandiva/llvm_generator.h
+++ b/cpp/src/gandiva/llvm_generator.h
@@ -23,15 +23,17 @@
 #include <vector>
 
 #include "arrow/util/macros.h"
-
 #include "gandiva/annotator.h"
 #include "gandiva/compiled_expr.h"
 #include "gandiva/configuration.h"
 #include "gandiva/dex_visitor.h"
 #include "gandiva/engine.h"
 #include "gandiva/execution_context.h"
+#include "gandiva/expr_decomposer.h"
+#include "gandiva/expression_cache_key.h"
 #include "gandiva/function_registry.h"
 #include "gandiva/gandiva_aliases.h"
+#include "gandiva/gandiva_object_cache.h"
 #include "gandiva/llvm_types.h"
 #include "gandiva/lvalue.h"
 #include "gandiva/selection_vector.h"
@@ -49,15 +51,19 @@ class GANDIVA_EXPORT LLVMGenerator {
   static Status Make(std::shared_ptr<Configuration> config,
                      std::unique_ptr<LLVMGenerator>* llvm_generator);
 
-  /// \brief Build the code for the expression trees for default mode. Each
-  /// element in the vector represents an expression tree
+  static std::shared_ptr<Cache<ExpressionCacheKey, std::shared_ptr<llvm::MemoryBuffer>>>
+  GetCache();
+
+  /// Set LLVM ObjectCache.
+  void SetLLVMObjectCache(GandivaObjectCache& object_cache);
+
+  /// \brief Build the code for the expression trees for default mode with a LLVM
+  /// ObjectCache. Each element in the vector represents an expression tree
   Status Build(const ExpressionVector& exprs, SelectionVector::Mode mode);
 
   /// \brief Build the code for the expression trees for default mode. Each
   /// element in the vector represents an expression tree
-  Status Build(const ExpressionVector& exprs) {
-    return Build(exprs, SelectionVector::Mode::MODE_NONE);
-  }
+  Status Build(const ExpressionVector& exprs);
 
   /// \brief Execute the built expression against the provided arguments for
   /// default mode.
diff --git a/cpp/src/gandiva/precompiled/arithmetic_ops.cc b/cpp/src/gandiva/precompiled/arithmetic_ops.cc
index b543d96bb80..b272cfcb2b4 100644
--- a/cpp/src/gandiva/precompiled/arithmetic_ops.cc
+++ b/cpp/src/gandiva/precompiled/arithmetic_ops.cc
@@ -125,6 +125,69 @@ NUMERIC_DATE_TYPES(BINARY_RELATIONAL, greater_than_or_equal_to, >=)
 
 #undef BINARY_RELATIONAL
 
+// Returns the greatest or least value from a list of values
+#define COMPARE_TWO_VALUES(NAME, TYPE, OP)                            \
+  FORCE_INLINE                                                        \
+  gdv_##TYPE NAME##_##TYPE##_##TYPE(gdv_##TYPE in1, gdv_##TYPE in2) { \
+    return (in1 OP in2 ? in1 : in2);                                  \
+  }
+
+#define COMPARE_THREE_VALUES(NAME, TYPE, OP)                                 \
+  FORCE_INLINE                                                               \
+  gdv_##TYPE NAME##_##TYPE##_##TYPE##_##TYPE(gdv_##TYPE in1, gdv_##TYPE in2, \
+                                             gdv_##TYPE in3) {               \
+    gdv_##TYPE compared = (in1 OP in2 ? in1 : in2);                          \
+    return (compared OP in3 ? compared : in3);                               \
+  }
+
+#define COMPARE_FOUR_VALUES(NAME, TYPE, OP)                                             \
+  FORCE_INLINE                                                                          \
+  gdv_##TYPE NAME##_##TYPE##_##TYPE##_##TYPE##_##TYPE(gdv_##TYPE in1, gdv_##TYPE in2,   \
+                                                      gdv_##TYPE in3, gdv_##TYPE in4) { \
+    gdv_##TYPE compared = (in1 OP in2 ? in1 : in2);                                     \
+    compared = (compared OP in3 ? compared : in3);                                      \
+    return (compared OP in4 ? compared : in4);                                          \
+  }
+
+#define COMPARE_FIVE_VALUES(NAME, TYPE, OP)                                             \
+  FORCE_INLINE                                                                          \
+  gdv_##TYPE NAME##_##TYPE##_##TYPE##_##TYPE##_##TYPE##_##TYPE(                         \
+      gdv_##TYPE in1, gdv_##TYPE in2, gdv_##TYPE in3, gdv_##TYPE in4, gdv_##TYPE in5) { \
+    gdv_##TYPE compared = (in1 OP in2 ? in1 : in2);                                     \
+    compared = (compared OP in3 ? compared : in3);                                      \
+    compared = (compared OP in4 ? compared : in4);                                      \
+    return (compared OP in5 ? compared : in5);                                          \
+  }
+
+#define COMPARE_SIX_VALUES(NAME, TYPE, OP)                                            \
+  FORCE_INLINE                                                                        \
+  gdv_##TYPE NAME##_##TYPE##_##TYPE##_##TYPE##_##TYPE##_##TYPE##_##TYPE(              \
+      gdv_##TYPE in1, gdv_##TYPE in2, gdv_##TYPE in3, gdv_##TYPE in4, gdv_##TYPE in5, \
+      gdv_##TYPE in6) {                                                               \
+    gdv_##TYPE compared = (in1 OP in2 ? in1 : in2);                                   \
+    compared = (compared OP in3 ? compared : in3);                                    \
+    compared = (compared OP in4 ? compared : in4);                                    \
+    compared = (compared OP in5 ? compared : in5);                                    \
+    return (compared OP in6 ? compared : in6);                                        \
+  }
+
+NUMERIC_DATE_TYPES(COMPARE_TWO_VALUES, greatest, >)
+NUMERIC_DATE_TYPES(COMPARE_TWO_VALUES, least, <)
+NUMERIC_DATE_TYPES(COMPARE_THREE_VALUES, greatest, >)
+NUMERIC_DATE_TYPES(COMPARE_THREE_VALUES, least, <)
+NUMERIC_DATE_TYPES(COMPARE_FOUR_VALUES, greatest, >)
+NUMERIC_DATE_TYPES(COMPARE_FOUR_VALUES, least, <)
+NUMERIC_DATE_TYPES(COMPARE_FIVE_VALUES, greatest, >)
+NUMERIC_DATE_TYPES(COMPARE_FIVE_VALUES, least, <)
+NUMERIC_DATE_TYPES(COMPARE_SIX_VALUES, greatest, >)
+NUMERIC_DATE_TYPES(COMPARE_SIX_VALUES, least, <)
+
+#undef COMPARE_TWO_VALUES
+#undef COMPARE_THREE_VALUES
+#undef COMPARE_FOUR_VALUES
+#undef COMPARE_FIVE_VALUES
+#undef COMPARE_SIX_VALUES
+
 // cast fns : takes one param type, returns another type.
 #define CAST_UNARY(NAME, IN_TYPE, OUT_TYPE)           \
   FORCE_INLINE                                        \
@@ -169,6 +232,20 @@ NUMERIC_TYPES(VALIDITY_OP, isnumeric, +)
 
 #undef VALIDITY_OP
 
+#define IS_TRUE_OR_FALSE_BOOL(NAME, TYPE, OP) \
+  FORCE_INLINE                                \
+  gdv_##TYPE NAME##_boolean(gdv_##TYPE in) { return OP in; }
+
+IS_TRUE_OR_FALSE_BOOL(istrue, boolean, +)
+IS_TRUE_OR_FALSE_BOOL(isfalse, boolean, !)
+
+#define IS_TRUE_OR_FALSE_NUMERIC(NAME, TYPE, OP) \
+  FORCE_INLINE                                   \
+  gdv_boolean NAME##_##TYPE(gdv_##TYPE in) { return OP(in != 0 ? true : false); }
+
+NUMERIC_TYPES(IS_TRUE_OR_FALSE_NUMERIC, istrue, +)
+NUMERIC_TYPES(IS_TRUE_OR_FALSE_NUMERIC, isfalse, !)
+
 #define NUMERIC_FUNCTION(INNER) \
   INNER(int8)                   \
   INNER(int16)                  \
@@ -192,6 +269,17 @@ NUMERIC_TYPES(VALIDITY_OP, isnumeric, +)
   DATE_FUNCTION(INNER)                    \
   INNER(boolean)
 
+#define NVL(TYPE)                                                                  \
+  FORCE_INLINE                                                                     \
+  gdv_##TYPE nvl_##TYPE##_##TYPE(gdv_##TYPE in, gdv_boolean is_valid_in,           \
+                                 gdv_##TYPE replace, gdv_boolean is_valid_value) { \
+    return (is_valid_in ? in : replace);                                           \
+  }
+
+NUMERIC_BOOL_DATE_FUNCTION(NVL)
+
+#undef NVL
+
 FORCE_INLINE
 gdv_boolean not_boolean(gdv_boolean in) { return !in; }
 
diff --git a/cpp/src/gandiva/precompiled/arithmetic_ops_test.cc b/cpp/src/gandiva/precompiled/arithmetic_ops_test.cc
index c2f37e89bb6..f8448d839e2 100644
--- a/cpp/src/gandiva/precompiled/arithmetic_ops_test.cc
+++ b/cpp/src/gandiva/precompiled/arithmetic_ops_test.cc
@@ -117,6 +117,166 @@ TEST(TestArithmeticOps, TestDiv) {
   context.Reset();
 }
 
+TEST(TestArithmeticOps, TestGreatestLeast) {
+  // Comparable functions - Greatest and Least
+  EXPECT_EQ(greatest_int32_int32(1, 2), 2);
+  EXPECT_EQ(greatest_int32_int32(1, INT32_MAX), INT32_MAX);
+  EXPECT_EQ(greatest_int32_int32(2, 1), 2);
+  EXPECT_EQ(greatest_int64_int64(1, 2), 2);
+  EXPECT_EQ(greatest_int64_int64(1, INT64_MAX), INT64_MAX);
+  EXPECT_EQ(greatest_int64_int64(2, 1), 2);
+  EXPECT_EQ(greatest_float32_float32(1.0f, 2.0f), 2.0f);
+  EXPECT_EQ(greatest_float32_float32(1.0f, INFINITY), INFINITY);
+  EXPECT_EQ(greatest_float32_float32(1.0f, FLT_MAX), FLT_MAX);
+  EXPECT_EQ(greatest_float32_float32(2.0f, 1.0f), 2.0f);
+  EXPECT_EQ(greatest_float64_float64(1.0, 2.0), 2.0);
+  EXPECT_EQ(greatest_float64_float64(1.0, DBL_MAX), DBL_MAX);
+  EXPECT_EQ(greatest_float64_float64(2.0, 1.0), 2.0);
+  EXPECT_EQ(least_int32_int32(1, 2), 1);
+  EXPECT_EQ(least_int32_int32(INT32_MIN, 2), INT32_MIN);
+  EXPECT_EQ(least_int32_int32(2, 1), 1);
+  EXPECT_EQ(least_int64_int64(1, 2), 1);
+  EXPECT_EQ(least_int64_int64(INT64_MIN, 2), INT64_MIN);
+  EXPECT_EQ(least_int64_int64(2, 1), 1);
+  EXPECT_EQ(least_float32_float32(1.0f, 2.0f), 1.0f);
+  EXPECT_EQ(least_float32_float32(FLT_MIN, 2.0f), FLT_MIN);
+  EXPECT_EQ(least_float32_float32(2.0f, 1.0f), 1.0f);
+  EXPECT_EQ(least_float64_float64(1.0, 2.0), 1.0);
+  EXPECT_EQ(least_float64_float64(DBL_MIN, 2.0), DBL_MIN);
+  EXPECT_EQ(least_float64_float64(2.0, 1.0), 1.0);
+
+  EXPECT_EQ(greatest_int32_int32_int32(1, 2, 3), 3);
+  EXPECT_EQ(greatest_int32_int32_int32(3, 2, 1), 3);
+  EXPECT_EQ(greatest_int64_int64_int64(1, 2, 3), 3);
+  EXPECT_EQ(greatest_int64_int64_int64(3, 2, 1), 3);
+  EXPECT_EQ(greatest_float32_float32_float32(1.0f, 2.0f, 3.0f), 3.0f);
+  EXPECT_EQ(greatest_float32_float32_float32(3.0f, 2.0f, 1.0f), 3.0f);
+  EXPECT_EQ(greatest_float64_float64_float64(1.0, 2.0, 3.0), 3.0);
+  EXPECT_EQ(greatest_float64_float64_float64(3.0, 2.0, 1.0), 3.0);
+  EXPECT_EQ(least_int32_int32_int32(1, 2, 3), 1);
+  EXPECT_EQ(least_int32_int32_int32(2, 1, 3), 1);
+  EXPECT_EQ(least_int64_int64_int64(1, 2, 3), 1);
+  EXPECT_EQ(least_int64_int64_int64(2, 1, 3), 1);
+  EXPECT_EQ(least_float32_float32_float32(1.0f, 2.0f, 3.0f), 1.0f);
+  EXPECT_EQ(least_float32_float32_float32(3.0f, 2.0f, 1.0f), 1.0f);
+  EXPECT_EQ(least_float64_float64_float64(1.0, 2.0, 2.0), 1.0);
+  EXPECT_EQ(least_float64_float64_float64(3.0, 2.0, 1.0), 1.0);
+
+  EXPECT_EQ(greatest_int32_int32_int32_int32(1, 2, 3, 4), 4);
+  EXPECT_EQ(greatest_int32_int32_int32_int32(2, 4, 3, 1), 4);
+  EXPECT_EQ(greatest_int64_int64_int64_int64(1, 2, 3, 4), 4);
+  EXPECT_EQ(greatest_int64_int64_int64_int64(2, 4, 3, 1), 4);
+  EXPECT_EQ(greatest_float32_float32_float32_float32(1.0f, 2.0f, 3.0f, 4.0f), 4.0f);
+  EXPECT_EQ(greatest_float32_float32_float32_float32(2.0f, 4.0f, 3, 1.0f), 4.0f);
+  EXPECT_EQ(greatest_float64_float64_float64_float64(1.0, 2.0, 3.0, 4.0), 4.0);
+  EXPECT_EQ(greatest_float64_float64_float64_float64(2.0, 4.0, 3.0, 1.0), 4.0);
+  EXPECT_EQ(least_int32_int32_int32_int32(1, 2, 3, 4), 1);
+  EXPECT_EQ(least_int32_int32_int32_int32(2, 4, 3, 1), 1);
+  EXPECT_EQ(least_int64_int64_int64_int64(1, 2, 3, 4), 1);
+  EXPECT_EQ(least_int64_int64_int64_int64(2, 4, 3, 1), 1);
+  EXPECT_EQ(least_float32_float32_float32_float32(1.0f, 2.0f, 3.0f, 4.0f), 1.0f);
+  EXPECT_EQ(least_float32_float32_float32_float32(2.0f, 4.0f, 3, 1.0f), 1.0f);
+  EXPECT_EQ(least_float64_float64_float64_float64(1.0, 2.0, 3.0, 4.0), 1.0);
+  EXPECT_EQ(least_float64_float64_float64_float64(2.0, 4.0, 3.0, 1.0), 1.0);
+
+  EXPECT_EQ(greatest_int32_int32_int32_int32_int32(1, 2, 3, 5, 4), 5);
+  EXPECT_EQ(greatest_int32_int32_int32_int32_int32(2, 4, 5, 3, 1), 5);
+  EXPECT_EQ(greatest_int64_int64_int64_int64_int64(1, 2, 3, 5, 4), 5);
+  EXPECT_EQ(greatest_int64_int64_int64_int64_int64(2, 4, 5, 3, 1), 5);
+  EXPECT_EQ(
+      greatest_float32_float32_float32_float32_float32(1.0f, 2.0f, 3.0f, 5.0f, 4.0f),
+      5.0f);
+  EXPECT_EQ(
+      greatest_float32_float32_float32_float32_float32(2.0f, 4.0f, 5.0f, 3.0f, 1.0f),
+      5.0f);
+  EXPECT_EQ(greatest_float64_float64_float64_float64_float64(1.0, 2.0, 3.0, 5.0, 4.0),
+            5.0);
+  EXPECT_EQ(greatest_float64_float64_float64_float64_float64(2.0, 4.0, 5.0, 3.0, 1.0),
+            5.0);
+  EXPECT_EQ(least_int32_int32_int32_int32_int32(1, 2, 3, 4, -10), -10);
+  EXPECT_EQ(least_int32_int32_int32_int32_int32(-10, 4, 2, 1, 3), -10);
+  EXPECT_EQ(least_int64_int64_int64_int64_int64(1, 2, 3, 4, -10), -10);
+  EXPECT_EQ(least_int64_int64_int64_int64_int64(-10, 4, 2, 1, 3), -10);
+  EXPECT_EQ(least_float32_float32_float32_float32_float32(1.0f, 2.0f, 3.0f, -10.0f, 4.0f),
+            -10.0f);
+  EXPECT_EQ(least_float32_float32_float32_float32_float32(2.0f, 4.0f, -10.0f, 3.0f, 1.0f),
+            -10.0f);
+  EXPECT_EQ(least_float64_float64_float64_float64_float64(1.0, 2.0, 3.0, -10.0, 4.0),
+            -10.0);
+  EXPECT_EQ(least_float64_float64_float64_float64_float64(-10.0, 4.0, 5.0, 3.0, 1.0),
+            -10.0);
+
+  EXPECT_EQ(greatest_int32_int32_int32_int32_int32_int32(7, 1, 2, 3, 5, 4), 7);
+  EXPECT_EQ(greatest_int32_int32_int32_int32_int32_int32(2, 4, 7, 5, 3, 1), 7);
+  EXPECT_EQ(greatest_int64_int64_int64_int64_int64_int64(7, 1, 2, 3, 5, 4), 7);
+  EXPECT_EQ(greatest_int64_int64_int64_int64_int64_int64(2, 4, 7, 5, 3, 1), 7);
+  EXPECT_EQ(greatest_float32_float32_float32_float32_float32_float32(7.0f, 1.0f, 2.0f,
+                                                                     3.0f, 5.0f, 4.0f),
+            7.0f);
+  EXPECT_EQ(greatest_float32_float32_float32_float32_float32_float32(2.0f, 4.0f, 7.0f,
+                                                                     5.0f, 3.0f, 1.0f),
+            7.0f);
+  EXPECT_EQ(greatest_float64_float64_float64_float64_float64_float64(7.0, 1.0, 2.0, 3.0,
+                                                                     5.0, 4.0),
+            7.0);
+  EXPECT_EQ(greatest_float64_float64_float64_float64_float64_float64(2.0, 4.0, 7.0, 5.0,
+                                                                     3.0, 1.0),
+            7.0);
+
+  EXPECT_EQ(least_int32_int32_int32_int32_int32_int32(1, 2, 3, -99, 4, -10), -99);
+  EXPECT_EQ(least_int32_int32_int32_int32_int32_int32(-10, 4, 2, 1, -99, 3), -99);
+  EXPECT_EQ(least_int64_int64_int64_int64_int64_int64(1, 2, 3, -99, 4, -10), -99);
+  EXPECT_EQ(least_int64_int64_int64_int64_int64_int64(-10, 4, 2, 1, -99, 3), -99);
+  EXPECT_EQ(least_float32_float32_float32_float32_float32_float32(1.0f, 2.0f, 3.0f,
+                                                                  -99.0f, 4.0f, -10.0f),
+            -99.0f);
+  EXPECT_EQ(least_float32_float32_float32_float32_float32_float32(-10.0f, 4.0f, 2.0f,
+                                                                  1.0f, -99.0f, 3.0f),
+            -99.0f);
+  EXPECT_EQ(least_float64_float64_float64_float64_float64_float64(1.0, 2.0, 3.0, -99.0,
+                                                                  4.0, -10.0),
+            -99.0);
+  EXPECT_EQ(least_float64_float64_float64_float64_float64_float64(-10.0, 4.0, 2.0, 1.0,
+                                                                  -99.0, 3.0),
+            -99.0);
+}
+
+TEST(TestArithmeticOps, TestIsTrueFalse) {
+  EXPECT_EQ(istrue_boolean(true), true);
+  EXPECT_EQ(istrue_boolean(false), false);
+  EXPECT_EQ(isfalse_boolean(true), false);
+  EXPECT_EQ(isfalse_boolean(false), true);
+  EXPECT_EQ(istrue_int32(10), true);
+  EXPECT_EQ(istrue_int32(0), false);
+  EXPECT_EQ(isfalse_int32(10), false);
+  EXPECT_EQ(isfalse_int32(0), true);
+  EXPECT_EQ(istrue_int64(10), true);
+  EXPECT_EQ(istrue_int64(0), false);
+  EXPECT_EQ(isfalse_int64(10), false);
+  EXPECT_EQ(isfalse_int64(0), true);
+  EXPECT_EQ(istrue_uint32(10), true);
+  EXPECT_EQ(istrue_uint32(0), false);
+  EXPECT_EQ(isfalse_uint32(10), false);
+  EXPECT_EQ(isfalse_uint32(0), true);
+  EXPECT_EQ(istrue_uint64(10), true);
+  EXPECT_EQ(istrue_uint64(0), false);
+  EXPECT_EQ(isfalse_uint64(10), false);
+  EXPECT_EQ(isfalse_uint64(0), true);
+}
+
+TEST(TestArithmeticOps, TestNvl) {
+  EXPECT_EQ(nvl_int32_int32(10, false, 20, true), 20);
+  EXPECT_EQ(nvl_int64_int64(10, false, 20, true), 20);
+  EXPECT_EQ(nvl_float32_float32(10.0, false, 20.0, true), 20);
+  EXPECT_EQ(nvl_float64_float64(10.0, false, 20.0, true), 20);
+  EXPECT_EQ(nvl_boolean_boolean(true, false, false, true), false);
+  EXPECT_EQ(nvl_int32_int32(10, true, 20, true), 10);
+  EXPECT_EQ(nvl_int64_int64(10, true, 20, true), 10);
+  EXPECT_EQ(nvl_float32_float32(10.0, true, 20.0, true), 10);
+  EXPECT_EQ(nvl_float64_float64(10.0, true, 20.0, true), 10);
+  EXPECT_EQ(nvl_boolean_boolean(true, true, false, true), true);
+}
+
 TEST(TestArithmeticOps, TestBitwiseOps) {
   // bitwise AND
   EXPECT_EQ(bitwise_and_int32_int32(0x0147D, 0x17159), 0x01059);
diff --git a/cpp/src/gandiva/precompiled/bitmap.cc b/cpp/src/gandiva/precompiled/bitmap.cc
index 332f08dbe78..2f36f3fb966 100644
--- a/cpp/src/gandiva/precompiled/bitmap.cc
+++ b/cpp/src/gandiva/precompiled/bitmap.cc
@@ -31,7 +31,7 @@ extern "C" {
 
 FORCE_INLINE
 bool bitMapGetBit(const uint8_t* bmap, int64_t position) {
-  return arrow::BitUtil::GetBit(bmap, position);
+  return arrow::bit_util::GetBit(bmap, position);
 }
 
 FORCE_INLINE
@@ -46,14 +46,14 @@ bool bitMapValidityGetBit(const uint8_t* bmap, int64_t position) {
 
 FORCE_INLINE
 void bitMapSetBit(uint8_t* bmap, int64_t position, bool value) {
-  arrow::BitUtil::SetBitTo(bmap, position, value);
+  arrow::bit_util::SetBitTo(bmap, position, value);
 }
 
 // Clear the bit if value = false. Does nothing if value = true.
 FORCE_INLINE
 void bitMapClearBitIfFalse(uint8_t* bmap, int64_t position, bool value) {
   if (!value) {
-    arrow::BitUtil::ClearBit(bmap, position);
+    arrow::bit_util::ClearBit(bmap, position);
   }
 }
 
diff --git a/cpp/src/gandiva/precompiled/extended_math_ops.cc b/cpp/src/gandiva/precompiled/extended_math_ops.cc
index c2331976c6d..96fe7fb9e3e 100644
--- a/cpp/src/gandiva/precompiled/extended_math_ops.cc
+++ b/cpp/src/gandiva/precompiled/extended_math_ops.cc
@@ -227,6 +227,49 @@ gdv_int32 round_int32(gdv_int32 num) { return num; }
 FORCE_INLINE
 gdv_int64 round_int64(gdv_int64 num) { return num; }
 
+// Lookup table to make the factorial function to execute faster
+// It is used because the range of values for the function is limited to [0!-20!]
+static const int64_t kFactorialLookupTable[] = {1,
+                                                1,
+                                                2,
+                                                6,
+                                                24,
+                                                120,
+                                                720,
+                                                5040,
+                                                40320,
+                                                362880,
+                                                3628800,
+                                                39916800,
+                                                479001600,
+                                                6227020800,
+                                                87178291200,
+                                                1307674368000,
+                                                20922789888000,
+                                                355687428096000,
+                                                6402373705728000,
+                                                121645100408832000,
+                                                2432902008176640000};
+
+#define FACTORIAL(IN_TYPE)                                                          \
+  FORCE_INLINE                                                                      \
+  gdv_int64 factorial_##IN_TYPE(gdv_int64 ctx, gdv_##IN_TYPE value) {               \
+    if (value < 0) {                                                                \
+      gdv_fn_context_set_error_msg(ctx, "Factorial of negative number not exist!"); \
+      return 0;                                                                     \
+    }                                                                               \
+    /* For numbers greater than 20 causes an overflow. */                           \
+    if (value > 20) {                                                               \
+      gdv_fn_context_set_error_msg(ctx, "Numbers greater than 20 cause overflow!"); \
+      return 0;                                                                     \
+    }                                                                               \
+                                                                                    \
+    return kFactorialLookupTable[static_cast<int32_t>(value)];                      \
+  }
+
+FACTORIAL(int32)
+FACTORIAL(int64)
+
 // rounds the number to the nearest integer
 #define ROUND_DECIMAL(TYPE)                                                 \
   FORCE_INLINE                                                              \
diff --git a/cpp/src/gandiva/precompiled/extended_math_ops_test.cc b/cpp/src/gandiva/precompiled/extended_math_ops_test.cc
index 9d84734217b..3e9d8a5d2cd 100644
--- a/cpp/src/gandiva/precompiled/extended_math_ops_test.cc
+++ b/cpp/src/gandiva/precompiled/extended_math_ops_test.cc
@@ -20,7 +20,9 @@
 #endif
 
 #include <gtest/gtest.h>
+
 #include <cmath>
+
 #include "gandiva/execution_context.h"
 #include "gandiva/precompiled/types.h"
 
@@ -43,6 +45,47 @@ TEST(TestExtendedMathOps, TestCbrt) {
   VerifyFuzzyEquals(cbrt_float64(15.625), 2.5);
 }
 
+TEST(TestExtendedMathOps, TestFactorial) {
+  gandiva::ExecutionContext context;
+  auto ctx = reinterpret_cast<int64_t>(&context);
+
+  for (int32_t i = 0; i <= 20; ++i) {
+    int64_t expected_factorial = 1;
+
+    for (int64_t j = 1; j <= i; ++j) {
+      expected_factorial *= j;
+    }
+
+    EXPECT_EQ(factorial_int32(ctx, i), expected_factorial);
+  }
+
+  factorial_int32(ctx, 21);
+  EXPECT_TRUE(context.get_error().find("overflow") != std::string::npos);
+  context.Reset();
+
+  factorial_int32(ctx, -5);
+  EXPECT_TRUE(context.get_error().find("Factorial of negative") != std::string::npos);
+  context.Reset();
+
+  for (int64_t i = 0; i <= 20; ++i) {
+    int64_t expected_factorial = 1;
+
+    for (int64_t j = 1; j <= i; ++j) {
+      expected_factorial *= j;
+    }
+
+    EXPECT_EQ(factorial_int64(ctx, i), expected_factorial);
+  }
+
+  factorial_int64(ctx, 21);
+  EXPECT_TRUE(context.get_error().find("overflow") != std::string::npos);
+  context.Reset();
+
+  factorial_int64(ctx, -5);
+  EXPECT_TRUE(context.get_error().find("Factorial of negative") != std::string::npos);
+  context.Reset();
+}
+
 TEST(TestExtendedMathOps, TestExp) {
   double val = 20.085536923187668;
 
diff --git a/cpp/src/gandiva/precompiled/string_ops.cc b/cpp/src/gandiva/precompiled/string_ops.cc
index a43208cfff3..0588af82482 100644
--- a/cpp/src/gandiva/precompiled/string_ops.cc
+++ b/cpp/src/gandiva/precompiled/string_ops.cc
@@ -1684,6 +1684,105 @@ const char* convert_toUTF8(int64_t context, const char* value, int32_t value_len
   return value;
 }
 
+// Calculate the levenshtein distance between two string values
+FORCE_INLINE
+gdv_int32 levenshtein(int64_t context, const char* in1, int32_t in1_len, const char* in2,
+                      int32_t in2_len) {
+  if (in1_len < 0 || in2_len < 0) {
+    gdv_fn_context_set_error_msg(context, "String length must be greater than 0");
+    return 0;
+  }
+
+  // Check input size 0
+  if (in1_len == 0) {
+    return in2_len;
+  }
+  if (in2_len == 0) {
+    return in1_len;
+  }
+
+  // arr_larger and arr_smaller is one pointer for entrys
+  const char* arr_larger;
+  const char* arr_smaller;
+  // len_larger and len_smaller is one copy from lengths
+  int len_larger;
+  int len_smaller;
+
+  if (in1_len < in2_len) {
+    len_larger = in2_len;
+    arr_larger = in2;
+
+    len_smaller = in1_len;
+    arr_smaller = in1;
+  } else {
+    len_larger = in1_len;
+    arr_larger = in1;
+
+    len_smaller = in2_len;
+    arr_smaller = in2;
+  }
+
+  int* ptr =
+      reinterpret_cast<int*>(gdv_fn_context_arena_malloc(context, (len_smaller + 1) * 2));
+  if (ptr == nullptr) {
+    gdv_fn_context_set_error_msg(context, "String length must be greater than 0");
+    return 0;
+  }
+
+  // MEMORY ADRESS MALLOC
+  // v0 -> (0, ..., &ptr[in2_len])
+  // v1 -> (in2_len+1, ..., &ptr[in2_len * 2])
+  int* v0;
+  int* v1;
+  int* aux;
+  v0 = &ptr[0];
+  v1 = &ptr[len_smaller + 1];
+
+  // Initializate v0
+  for (int i = 0; i <= len_smaller; i++) {
+    v0[i] = i;
+  }
+
+  // Initialize interactive mode
+  for (int i = 0; i < len_larger; i++) {
+    // The first element to V1 is [i + 1]
+    // For edit distance you can delete (i+1) chars from in1 to match empty in2 position
+    v1[0] = i + 1;
+
+    for (int j = 0; j < len_smaller; j++) {
+      // Calculate costs to modify
+      int deletionCost = v0[j + 1] + 1;
+      int insertionCost = v1[j] + 1;
+      int substitutionCost = v0[j] + 1;
+
+      if (arr_larger[i] == arr_smaller[j]) {
+        substitutionCost = v0[j];
+      }
+
+      // Catch the minor cost
+      int min;
+      min = deletionCost;
+
+      if (min > substitutionCost) {
+        min = substitutionCost;
+      }
+      if (min > insertionCost) {
+        min = insertionCost;
+      }
+
+      // Set the minor cost to v1
+      v1[j + 1] = min;
+    }
+
+    // Swaping v0 and v1
+    aux = v0;
+    v0 = v1;
+    v1 = aux;
+  }
+  // The results of v1 are now in v0, Levenshtein value is in v0[n]
+  return v0[len_smaller];
+}
+
 // Search for a string within another string
 // Same as "locate(substr, str)", except for the reverse order of the arguments.
 FORCE_INLINE
@@ -2040,16 +2139,7 @@ const char* split_part(gdv_int64 context, const char* text, gdv_int32 text_len,
         }
 
         *out_len = end_pos - i;
-        char* out_str =
-            reinterpret_cast<char*>(gdv_fn_context_arena_malloc(context, *out_len));
-        if (out_str == nullptr) {
-          gdv_fn_context_set_error_msg(context,
-                                       "Could not allocate memory for output string");
-          *out_len = 0;
-          return "";
-        }
-        memcpy(out_str, text + i, *out_len);
-        return out_str;
+        return text + i;
       } else {
         i = match_pos;
         match_no++;
diff --git a/cpp/src/gandiva/precompiled/string_ops_test.cc b/cpp/src/gandiva/precompiled/string_ops_test.cc
index 5cd3329502c..9b4dee9f7ee 100644
--- a/cpp/src/gandiva/precompiled/string_ops_test.cc
+++ b/cpp/src/gandiva/precompiled/string_ops_test.cc
@@ -995,6 +995,59 @@ TEST(TestStringOps, TestReverse) {
   ctx.Reset();
 }
 
+TEST(TestStringOps, TestLevenshtein) {
+  gandiva::ExecutionContext ctx;
+  uint64_t ctx_ptr = reinterpret_cast<gdv_int64>(&ctx);
+
+  EXPECT_EQ(levenshtein(ctx_ptr, "kitten", 6, "sitting", 7), 3);
+  EXPECT_FALSE(ctx.has_error());
+
+  EXPECT_EQ(levenshtein(ctx_ptr, "book", 4, "back", 4), 2);
+  EXPECT_FALSE(ctx.has_error());
+
+  EXPECT_EQ(levenshtein(ctx_ptr, "", 0, "a", 1), 1);
+  EXPECT_FALSE(ctx.has_error());
+
+  EXPECT_EQ(levenshtein(ctx_ptr, "test", 4, "task", 4), 2);
+  EXPECT_FALSE(ctx.has_error());
+
+  EXPECT_EQ(levenshtein(ctx_ptr, "cat", 3, "coat", 4), 1);
+  EXPECT_FALSE(ctx.has_error());
+
+  EXPECT_EQ(levenshtein(ctx_ptr, "coat", 4, "coat", 4), 0);
+  EXPECT_FALSE(ctx.has_error());
+
+  EXPECT_EQ(levenshtein(ctx_ptr, "AAAA", 4, "aAAa", 4), 2);
+  EXPECT_FALSE(ctx.has_error());
+
+  EXPECT_EQ(levenshtein(ctx_ptr, "color", 5, "colour", 6), 1);
+  EXPECT_FALSE(ctx.has_error());
+
+  EXPECT_EQ(levenshtein(ctx_ptr, "Test String1", 12, "Test String2", 12), 1);
+  EXPECT_FALSE(ctx.has_error());
+
+  EXPECT_EQ(levenshtein(ctx_ptr, "TEST STRING1", 12, "test string2", 12), 11);
+  EXPECT_FALSE(ctx.has_error());
+
+  EXPECT_EQ(levenshtein(ctx_ptr, "", 0, "Test String2", 12), 12);
+  EXPECT_FALSE(ctx.has_error());
+
+  EXPECT_EQ(levenshtein(ctx_ptr, nullptr, 0, "Test String2", 12), 12);
+  EXPECT_FALSE(ctx.has_error());
+
+  EXPECT_EQ(levenshtein(ctx_ptr, "Test String2", 12, nullptr, 0), 12);
+  EXPECT_FALSE(ctx.has_error());
+
+  EXPECT_EQ(levenshtein(ctx_ptr, nullptr, 0, nullptr, 0), 0);
+  EXPECT_FALSE(ctx.has_error());
+
+  EXPECT_EQ(levenshtein(ctx_ptr, "book", -5, "back", 4), 0);
+  EXPECT_TRUE(ctx.has_error());
+  EXPECT_THAT(ctx.get_error(),
+              ::testing::HasSubstr("String length must be greater than 0"));
+  ctx.Reset();
+}
+
 TEST(TestStringOps, TestQuote) {
   gandiva::ExecutionContext ctx;
   uint64_t ctx_ptr = reinterpret_cast<gdv_int64>(&ctx);
@@ -1764,6 +1817,9 @@ TEST(TestStringOps, TestSplitPart) {
   gdv_int32 out_len = 0;
   const char* out_str;
 
+  out_str = split_part(ctx_ptr, "abc::def", 8, ":", 1, 2, &out_len);
+  EXPECT_EQ(std::string(out_str, out_len), "");
+
   out_str = split_part(ctx_ptr, "A,B,C", 5, ",", 1, 0, &out_len);
   EXPECT_EQ(std::string(out_str, out_len), "");
   EXPECT_THAT(
diff --git a/cpp/src/gandiva/precompiled/time.cc b/cpp/src/gandiva/precompiled/time.cc
index 336f692267d..3835c0bdbb7 100644
--- a/cpp/src/gandiva/precompiled/time.cc
+++ b/cpp/src/gandiva/precompiled/time.cc
@@ -823,6 +823,12 @@ const char* castVARCHAR_timestamp_int64(gdv_int64 context, gdv_timestamp in,
   return ret;
 }
 
+#define IS_NULL(TYPE) \
+  FORCE_INLINE        \
+  bool isnull_##TYPE(gdv_##TYPE in, gdv_boolean is_valid) { return !is_valid; }
+IS_NULL(day_time_interval)
+IS_NULL(month_interval)
+
 FORCE_INLINE
 gdv_int64 extractDay_daytimeinterval(gdv_day_time_interval in) {
   gdv_int32 days = static_cast<gdv_int32>(in & 0x00000000FFFFFFFF);
diff --git a/cpp/src/gandiva/precompiled/time_test.cc b/cpp/src/gandiva/precompiled/time_test.cc
index 332ffa3325e..231e72f0204 100644
--- a/cpp/src/gandiva/precompiled/time_test.cc
+++ b/cpp/src/gandiva/precompiled/time_test.cc
@@ -711,6 +711,11 @@ TEST(TestTime, TestExtractWeek) {
   }
 }
 
+TEST(TestTime, TestIsNullInterval) {
+  EXPECT_EQ(isnull_day_time_interval(150, true), false);
+  EXPECT_EQ(isnull_day_time_interval(150, false), true);
+}
+
 TEST(TestTime, TestMonthsBetween) {
   std::vector<std::string> testStrings = {
       "1995-03-02 00:00:00", "1995-02-02 00:00:00", "1.0",
diff --git a/cpp/src/gandiva/precompiled/types.h b/cpp/src/gandiva/precompiled/types.h
index 9698e4eee60..cac5eea2b2a 100644
--- a/cpp/src/gandiva/precompiled/types.h
+++ b/cpp/src/gandiva/precompiled/types.h
@@ -114,6 +114,30 @@ gdv_int64 timestampaddMonth_timestamp_int64(gdv_timestamp, gdv_int64);
 gdv_int64 timestampaddQuarter_timestamp_int64(gdv_timestamp, gdv_int64);
 gdv_int64 timestampaddYear_timestamp_int64(gdv_timestamp, gdv_int64);
 
+gdv_boolean isnull_day_time_interval(gdv_day_time_interval in, gdv_boolean is_valid);
+
+gdv_boolean istrue_boolean(gdv_boolean in);
+gdv_boolean isfalse_boolean(gdv_boolean in);
+gdv_boolean istrue_int32(gdv_int32 in);
+gdv_boolean istrue_int64(gdv_int64 in);
+gdv_boolean istrue_uint32(gdv_uint32 in);
+gdv_boolean istrue_uint64(gdv_uint64 in);
+gdv_boolean isfalse_int32(gdv_int32 in);
+gdv_boolean isfalse_int64(gdv_int64 in);
+gdv_boolean isfalse_uint32(gdv_uint32 in);
+gdv_boolean isfalse_uint64(gdv_uint64 in);
+
+gdv_int32 nvl_int32_int32(gdv_int32 in, gdv_boolean is_valid_in, gdv_int32 replace,
+                          gdv_boolean is_valid_value);
+gdv_int64 nvl_int64_int64(gdv_int64 in, gdv_boolean is_valid_in, gdv_int64 replace,
+                          gdv_boolean is_valid_value);
+gdv_float32 nvl_float32_float32(gdv_float32 in, gdv_boolean is_valid_in,
+                                gdv_float32 replace, gdv_boolean is_valid_value);
+gdv_float64 nvl_float64_float64(gdv_float64 in, gdv_boolean is_valid_in,
+                                gdv_float64 replace, gdv_boolean is_valid_value);
+gdv_boolean nvl_boolean_boolean(gdv_boolean in, gdv_boolean is_valid_in,
+                                gdv_boolean replace, gdv_boolean is_valid_value);
+
 gdv_int64 date_add_int32_timestamp(gdv_int32, gdv_timestamp);
 gdv_int64 add_int64_timestamp(gdv_int64, gdv_timestamp);
 gdv_int64 add_int32_timestamp(gdv_int32, gdv_timestamp);
@@ -262,6 +286,89 @@ gdv_int64 bitwise_xor_int64_int64(gdv_int64 in1, gdv_int64 in2);
 gdv_int32 bitwise_not_int32(gdv_int32);
 gdv_int64 bitwise_not_int64(gdv_int64);
 
+gdv_int32 greatest_int32_int32(gdv_int32 in1, gdv_int32 in2);
+gdv_int64 greatest_int64_int64(gdv_int64 in1, gdv_int64 in2);
+gdv_int32 greatest_int32_int32_int32(gdv_int32 in1, gdv_int32 in2, gdv_int32 in3);
+gdv_int64 greatest_int64_int64_int64(gdv_int64 in1, gdv_int64 in2, gdv_int64 in3);
+gdv_int32 greatest_int32_int32_int32_int32(gdv_int32 in1, gdv_int32 in2, gdv_int32 in3,
+                                           gdv_int32 in4);
+gdv_int64 greatest_int64_int64_int64_int64(gdv_int64 in1, gdv_int64 in2, gdv_int64 in3,
+                                           gdv_int64 in4);
+gdv_int32 greatest_int32_int32_int32_int32_int32(gdv_int32 in1, gdv_int32 in2,
+                                                 gdv_int32 in3, gdv_int32 in4,
+                                                 gdv_int32 in5);
+gdv_int64 greatest_int64_int64_int64_int64_int64(gdv_int64 in1, gdv_int64 in2,
+                                                 gdv_int64 in3, gdv_int64 in4,
+                                                 gdv_int64 in5);
+gdv_int32 greatest_int32_int32_int32_int32_int32_int32(gdv_int32 in1, gdv_int32 in2,
+                                                       gdv_int32 in3, gdv_int32 in4,
+                                                       gdv_int32 in5, gdv_int32 in6);
+gdv_int64 greatest_int64_int64_int64_int64_int64_int64(gdv_int64 in1, gdv_int64 in2,
+                                                       gdv_int64 in3, gdv_int64 in4,
+                                                       gdv_int64 in5, gdv_int64 in6);
+gdv_float32 greatest_float32_float32(gdv_float32 in1, gdv_float32 in2);
+gdv_float64 greatest_float64_float64(gdv_float64 in1, gdv_float64 in2);
+gdv_float32 greatest_float32_float32_float32(gdv_float32 in1, gdv_float32 in2,
+                                             gdv_float32 in3);
+gdv_float64 greatest_float64_float64_float64(gdv_float64 in1, gdv_float64 in2,
+                                             gdv_float64 in3);
+gdv_float32 greatest_float32_float32_float32_float32(gdv_float32 in1, gdv_float32 in2,
+                                                     gdv_float32 in3, gdv_float32 in4);
+gdv_float64 greatest_float64_float64_float64_float64(gdv_float64 in1, gdv_float64 in2,
+                                                     gdv_float64 in3, gdv_float64 in4);
+gdv_float32 greatest_float32_float32_float32_float32_float32(
+    gdv_float32 in1, gdv_float32 in2, gdv_float32 in3, gdv_float32 in4, gdv_float32 in5);
+gdv_float64 greatest_float64_float64_float64_float64_float64(
+    gdv_float64 in1, gdv_float64 in2, gdv_float64 in3, gdv_float64 in4, gdv_float64 in5);
+gdv_float32 greatest_float32_float32_float32_float32_float32_float32(
+    gdv_float32 in1, gdv_float32 in2, gdv_float32 in3, gdv_float32 in4, gdv_float32 in5,
+    gdv_float32 in6);
+gdv_float64 greatest_float64_float64_float64_float64_float64_float64(
+    gdv_float64 in1, gdv_float64 in2, gdv_float64 in3, gdv_float64 in4, gdv_float64 in5,
+    gdv_float64 in6);
+
+gdv_int32 least_int32_int32(gdv_int32 in1, gdv_int32 in2);
+gdv_int64 least_int64_int64(gdv_int64 in1, gdv_int64 in2);
+gdv_int32 least_int32_int32_int32(gdv_int32 in1, gdv_int32 in2, gdv_int32 in3);
+gdv_int64 least_int64_int64_int64(gdv_int64 in1, gdv_int64 in2, gdv_int64 in3);
+gdv_int32 least_int32_int32_int32_int32(gdv_int32 in1, gdv_int32 in2, gdv_int32 in3,
+                                        gdv_int32 in4);
+gdv_int64 least_int64_int64_int64_int64(gdv_int64 in1, gdv_int64 in2, gdv_int64 in3,
+                                        gdv_int64 in4);
+gdv_int32 least_int32_int32_int32_int32_int32(gdv_int32 in1, gdv_int32 in2, gdv_int32 in3,
+                                              gdv_int32 in4, gdv_int32 in5);
+gdv_int64 least_int64_int64_int64_int64_int64(gdv_int64 in1, gdv_int64 in2, gdv_int64 in3,
+                                              gdv_int64 in4, gdv_int64 in5);
+gdv_int32 least_int32_int32_int32_int32_int32_int32(gdv_int32 in1, gdv_int32 in2,
+                                                    gdv_int32 in3, gdv_int32 in4,
+                                                    gdv_int32 in5, gdv_int32 in6);
+gdv_int64 least_int64_int64_int64_int64_int64_int64(gdv_int64 in1, gdv_int64 in2,
+                                                    gdv_int64 in3, gdv_int64 in4,
+                                                    gdv_int64 in5, gdv_int64 in6);
+gdv_float32 least_float32_float32(gdv_float32 in1, gdv_float32 in2);
+gdv_float64 least_float64_float64(gdv_float64 in1, gdv_float64 in2);
+gdv_float32 least_float32_float32_float32(gdv_float32 in1, gdv_float32 in2,
+                                          gdv_float32 in3);
+gdv_float64 least_float64_float64_float64(gdv_float64 in1, gdv_float64 in2,
+                                          gdv_float64 in3);
+gdv_float32 least_float32_float32_float32_float32(gdv_float32 in1, gdv_float32 in2,
+                                                  gdv_float32 in3, gdv_float32 in4);
+gdv_float64 least_float64_float64_float64_float64(gdv_float64 in1, gdv_float64 in2,
+                                                  gdv_float64 in3, gdv_float64 in4);
+gdv_float32 least_float32_float32_float32_float32_float32(
+    gdv_float32 in1, gdv_float32 in2, gdv_float32 in3, gdv_float32 in4, gdv_float32 in5);
+gdv_float64 least_float64_float64_float64_float64_float64(
+    gdv_float64 in1, gdv_float64 in2, gdv_float64 in3, gdv_float64 in4, gdv_float64 in5);
+gdv_float32 least_float32_float32_float32_float32_float32_float32(
+    gdv_float32 in1, gdv_float32 in2, gdv_float32 in3, gdv_float32 in4, gdv_float32 in5,
+    gdv_float32 in6);
+gdv_float64 least_float64_float64_float64_float64_float64_float64(
+    gdv_float64 in1, gdv_float64 in2, gdv_float64 in3, gdv_float64 in4, gdv_float64 in5,
+    gdv_float64 in6);
+
+gdv_int64 factorial_int32(gdv_int64 context, gdv_int32 value);
+gdv_int64 factorial_int64(gdv_int64 context, gdv_int64 value);
+
 gdv_float64 power_float64_float64(gdv_float64, gdv_float64);
 
 gdv_float64 log_int32_int32(gdv_int64 context, gdv_int32 base, gdv_int32 value);
@@ -429,6 +536,9 @@ const char* castVARBINARY_binary_int64(gdv_int64 context, const char* data,
                                        gdv_int32 data_len, int64_t out_len,
                                        int32_t* out_length);
 
+gdv_int32 levenshtein(int64_t context, const char* in1, int32_t in1_len, const char* in2,
+                      int32_t in2_len);
+
 const char* reverse_utf8(gdv_int64 context, const char* data, gdv_int32 data_len,
                          int32_t* out_len);
 
diff --git a/cpp/src/gandiva/projector.cc b/cpp/src/gandiva/projector.cc
index ff167538f9c..d73bbabf43d 100644
--- a/cpp/src/gandiva/projector.cc
+++ b/cpp/src/gandiva/projector.cc
@@ -18,109 +18,18 @@
 #include "gandiva/projector.h"
 
 #include <memory>
-#include <thread>
 #include <utility>
 #include <vector>
 
-#include "arrow/util/hash_util.h"
 #include "arrow/util/logging.h"
-
 #include "gandiva/cache.h"
 #include "gandiva/expr_validator.h"
+#include "gandiva/expression_cache_key.h"
+#include "gandiva/gandiva_object_cache.h"
 #include "gandiva/llvm_generator.h"
 
 namespace gandiva {
 
-class ProjectorCacheKey {
- public:
-  ProjectorCacheKey(SchemaPtr schema, std::shared_ptr<Configuration> configuration,
-                    ExpressionVector expression_vector, SelectionVector::Mode mode)
-      : schema_(schema), configuration_(configuration), mode_(mode), uniqifier_(0) {
-    static const int kSeedValue = 4;
-    size_t result = kSeedValue;
-    for (auto& expr : expression_vector) {
-      std::string expr_as_string = expr->ToString();
-      expressions_as_strings_.push_back(expr_as_string);
-      arrow::internal::hash_combine(result, expr_as_string);
-      UpdateUniqifier(expr_as_string);
-    }
-    arrow::internal::hash_combine(result, static_cast<size_t>(mode));
-    arrow::internal::hash_combine(result, configuration->Hash());
-    arrow::internal::hash_combine(result, schema_->ToString());
-    arrow::internal::hash_combine(result, uniqifier_);
-    hash_code_ = result;
-  }
-
-  std::size_t Hash() const { return hash_code_; }
-
-  bool operator==(const ProjectorCacheKey& other) const {
-    // arrow schema does not overload equality operators.
-    if (!(schema_->Equals(*other.schema().get(), true))) {
-      return false;
-    }
-
-    if (*configuration_ != *other.configuration_) {
-      return false;
-    }
-
-    if (expressions_as_strings_ != other.expressions_as_strings_) {
-      return false;
-    }
-
-    if (mode_ != other.mode_) {
-      return false;
-    }
-
-    if (uniqifier_ != other.uniqifier_) {
-      return false;
-    }
-    return true;
-  }
-
-  bool operator!=(const ProjectorCacheKey& other) const { return !(*this == other); }
-
-  SchemaPtr schema() const { return schema_; }
-
-  std::string ToString() const {
-    std::stringstream ss;
-    // indent, window, indent_size, null_rep and skip new lines.
-    arrow::PrettyPrintOptions options{0, 10, 2, "null", true};
-    DCHECK_OK(PrettyPrint(*schema_.get(), options, &ss));
-
-    ss << "Expressions: [";
-    bool first = true;
-    for (auto& expr : expressions_as_strings_) {
-      if (first) {
-        first = false;
-      } else {
-        ss << ", ";
-      }
-
-      ss << expr;
-    }
-    ss << "]";
-    return ss.str();
-  }
-
- private:
-  void UpdateUniqifier(const std::string& expr) {
-    if (uniqifier_ == 0) {
-      // caching of expressions with re2 patterns causes lock contention. So, use
-      // multiple instances to reduce contention.
-      if (expr.find(" like(") != std::string::npos) {
-        uniqifier_ = std::hash<std::thread::id>()(std::this_thread::get_id()) % 16;
-      }
-    }
-  }
-
-  const SchemaPtr schema_;
-  const std::shared_ptr<Configuration> configuration_;
-  SelectionVector::Mode mode_;
-  std::vector<std::string> expressions_as_strings_;
-  size_t hash_code_;
-  uint32_t uniqifier_;
-};
-
 Projector::Projector(std::unique_ptr<LLVMGenerator> llvm_generator, SchemaPtr schema,
                      const FieldVector& output_fields,
                      std::shared_ptr<Configuration> configuration)
@@ -153,15 +62,23 @@ Status Projector::Make(SchemaPtr schema, const ExpressionVector& exprs,
   ARROW_RETURN_IF(configuration == nullptr,
                   Status::Invalid("Configuration cannot be null"));
 
-  // see if equivalent projector was already built
-  static Cache<ProjectorCacheKey, std::shared_ptr<Projector>> cache;
-  ProjectorCacheKey cache_key(schema, configuration, exprs, selection_vector_mode);
-  std::shared_ptr<Projector> cached_projector = cache.GetModule(cache_key);
-  if (cached_projector != nullptr) {
-    *projector = cached_projector;
-    return Status::OK();
+  std::shared_ptr<Cache<ExpressionCacheKey, std::shared_ptr<llvm::MemoryBuffer>>> cache =
+      LLVMGenerator::GetCache();
+
+  ExpressionCacheKey cache_key(schema, configuration, exprs, selection_vector_mode);
+
+  bool llvm_flag = false;
+
+  std::shared_ptr<llvm::MemoryBuffer> prev_cached_obj;
+  prev_cached_obj = cache->GetObjectCode(cache_key);
+
+  // Verify if previous projector obj code was cached
+  if (prev_cached_obj != nullptr) {
+    llvm_flag = true;
   }
 
+  GandivaObjectCache obj_cache(cache, cache_key);
+
   // Build LLVM generator, and generate code for the specified expressions
   std::unique_ptr<LLVMGenerator> llvm_gen;
   ARROW_RETURN_NOT_OK(LLVMGenerator::Make(configuration, &llvm_gen));
@@ -174,13 +91,10 @@ Status Projector::Make(SchemaPtr schema, const ExpressionVector& exprs,
     ARROW_RETURN_NOT_OK(expr_validator.Validate(expr));
   }
 
-  // Start measuring build time
-  auto begin = std::chrono::high_resolution_clock::now();
+  // Set the object cache for LLVM
+  llvm_gen->SetLLVMObjectCache(obj_cache);
+
   ARROW_RETURN_NOT_OK(llvm_gen->Build(exprs, selection_vector_mode));
-  // Stop measuring time and calculate the elapsed time
-  auto end = std::chrono::high_resolution_clock::now();
-  auto elapsed =
-      std::chrono::duration_cast<std::chrono::milliseconds>(end - begin).count();
 
   // save the output field types. Used for validation at Evaluate() time.
   std::vector<FieldPtr> output_fields;
@@ -192,8 +106,7 @@ Status Projector::Make(SchemaPtr schema, const ExpressionVector& exprs,
   // Instantiate the projector with the completely built llvm generator
   *projector = std::shared_ptr<Projector>(
       new Projector(std::move(llvm_gen), schema, output_fields, configuration));
-  ValueCacheObject<std::shared_ptr<Projector>> value_cache(*projector, elapsed);
-  cache.PutModule(cache_key, value_cache);
+  projector->get()->SetBuiltFromCache(llvm_flag);
 
   return Status::OK();
 }
@@ -275,14 +188,14 @@ Status Projector::AllocArrayData(const DataTypePtr& type, int64_t num_records,
   std::vector<std::shared_ptr<arrow::Buffer>> buffers;
 
   // The output vector always has a null bitmap.
-  int64_t size = arrow::BitUtil::BytesForBits(num_records);
+  int64_t size = arrow::bit_util::BytesForBits(num_records);
   ARROW_ASSIGN_OR_RAISE(auto bitmap_buffer, arrow::AllocateBuffer(size, pool));
   buffers.push_back(std::move(bitmap_buffer));
 
   // String/Binary vectors have an offsets array.
   auto type_id = type->id();
   if (arrow::is_binary_like(type_id)) {
-    auto offsets_len = arrow::BitUtil::BytesForBits((num_records + 1) * 32);
+    auto offsets_len = arrow::bit_util::BytesForBits((num_records + 1) * 32);
 
     ARROW_ASSIGN_OR_RAISE(auto offsets_buffer, arrow::AllocateBuffer(offsets_len, pool));
     buffers.push_back(std::move(offsets_buffer));
@@ -292,7 +205,7 @@ Status Projector::AllocArrayData(const DataTypePtr& type, int64_t num_records,
   int64_t data_len;
   if (arrow::is_primitive(type_id) || type_id == arrow::Type::DECIMAL) {
     const auto& fw_type = dynamic_cast<const arrow::FixedWidthType&>(*type);
-    data_len = arrow::BitUtil::BytesForBits(num_records * fw_type.bit_width());
+    data_len = arrow::bit_util::BytesForBits(num_records * fw_type.bit_width());
   } else if (arrow::is_binary_like(type_id)) {
     // we don't know the expected size for varlen output vectors.
     data_len = 0;
@@ -327,7 +240,7 @@ Status Projector::ValidateArrayDataCapacity(const arrow::ArrayData& array_data,
   ARROW_RETURN_IF(array_data.buffers.size() < 2,
                   Status::Invalid("ArrayData must have at least 2 buffers"));
 
-  int64_t min_bitmap_len = arrow::BitUtil::BytesForBits(num_records);
+  int64_t min_bitmap_len = arrow::bit_util::BytesForBits(num_records);
   int64_t bitmap_len = array_data.buffers[0]->capacity();
   ARROW_RETURN_IF(
       bitmap_len < min_bitmap_len,
@@ -337,7 +250,7 @@ Status Projector::ValidateArrayDataCapacity(const arrow::ArrayData& array_data,
   auto type_id = field.type()->id();
   if (arrow::is_binary_like(type_id)) {
     // validate size of offsets buffer.
-    int64_t min_offsets_len = arrow::BitUtil::BytesForBits((num_records + 1) * 32);
+    int64_t min_offsets_len = arrow::bit_util::BytesForBits((num_records + 1) * 32);
     int64_t offsets_len = array_data.buffers[1]->capacity();
     ARROW_RETURN_IF(
         offsets_len < min_offsets_len,
@@ -353,7 +266,7 @@ Status Projector::ValidateArrayDataCapacity(const arrow::ArrayData& array_data,
     // verify size of data buffer.
     const auto& fw_type = dynamic_cast<const arrow::FixedWidthType&>(*field.type());
     int64_t min_data_len =
-        arrow::BitUtil::BytesForBits(num_records * fw_type.bit_width());
+        arrow::bit_util::BytesForBits(num_records * fw_type.bit_width());
     int64_t data_len = array_data.buffers[1]->capacity();
     ARROW_RETURN_IF(data_len < min_data_len,
                     Status::Invalid("Data buffer too small for ", field.name()));
@@ -366,4 +279,8 @@ Status Projector::ValidateArrayDataCapacity(const arrow::ArrayData& array_data,
 
 std::string Projector::DumpIR() { return llvm_generator_->DumpIR(); }
 
+void Projector::SetBuiltFromCache(bool flag) { built_from_cache_ = flag; }
+
+bool Projector::GetBuiltFromCache() { return built_from_cache_; }
+
 }  // namespace gandiva
diff --git a/cpp/src/gandiva/projector.h b/cpp/src/gandiva/projector.h
index 20b36c9d883..89492435bee 100644
--- a/cpp/src/gandiva/projector.h
+++ b/cpp/src/gandiva/projector.h
@@ -119,6 +119,9 @@ class GANDIVA_EXPORT Projector {
 
   std::string DumpIR();
 
+  void SetBuiltFromCache(bool flag);
+  bool GetBuiltFromCache();
+
  private:
   Projector(std::unique_ptr<LLVMGenerator> llvm_generator, SchemaPtr schema,
             const FieldVector& output_fields, std::shared_ptr<Configuration>);
@@ -138,6 +141,7 @@ class GANDIVA_EXPORT Projector {
   SchemaPtr schema_;
   FieldVector output_fields_;
   std::shared_ptr<Configuration> configuration_;
+  bool built_from_cache_;
 };
 
 }  // namespace gandiva
diff --git a/cpp/src/gandiva/selection_vector.cc b/cpp/src/gandiva/selection_vector.cc
index a30bba6864e..39e9f5bc902 100644
--- a/cpp/src/gandiva/selection_vector.cc
+++ b/cpp/src/gandiva/selection_vector.cc
@@ -50,7 +50,7 @@ Status SelectionVector::PopulateFromBitMap(const uint8_t* bitmap, int64_t bitmap
   int64_t selection_idx = 0;
   const uint64_t* bitmap_64 = reinterpret_cast<const uint64_t*>(bitmap);
   for (int64_t bitmap_idx = 0; bitmap_idx < bitmap_size / 8; ++bitmap_idx) {
-    uint64_t current_word = arrow::BitUtil::ToLittleEndian(bitmap_64[bitmap_idx]);
+    uint64_t current_word = arrow::bit_util::ToLittleEndian(bitmap_64[bitmap_idx]);
 
     while (current_word != 0) {
 #if defined(_MSC_VER)
@@ -64,7 +64,7 @@ Status SelectionVector::PopulateFromBitMap(const uint8_t* bitmap, int64_t bitmap
 #pragma warning(pop)
 #endif
 
-      int pos_in_word = arrow::BitUtil::CountTrailingZeros(highest_only);
+      int pos_in_word = arrow::bit_util::CountTrailingZeros(highest_only);
 
       int64_t pos_in_bitmap = bitmap_idx * 64 + pos_in_word;
       if (pos_in_bitmap > max_bitmap_index) {
diff --git a/cpp/src/gandiva/selection_vector_test.cc b/cpp/src/gandiva/selection_vector_test.cc
index 6868929018d..99568a5a36f 100644
--- a/cpp/src/gandiva/selection_vector_test.cc
+++ b/cpp/src/gandiva/selection_vector_test.cc
@@ -104,10 +104,10 @@ TEST_F(TestSelectionVector, TestInt16PopulateFromBitMap) {
   int bitmap_size = RoundUpNumi64(max_slots) * 8;
   std::vector<uint8_t> bitmap(bitmap_size);
 
-  arrow::BitUtil::SetBit(&bitmap[0], 0);
-  arrow::BitUtil::SetBit(&bitmap[0], 5);
-  arrow::BitUtil::SetBit(&bitmap[0], 121);
-  arrow::BitUtil::SetBit(&bitmap[0], 220);
+  arrow::bit_util::SetBit(&bitmap[0], 0);
+  arrow::bit_util::SetBit(&bitmap[0], 5);
+  arrow::bit_util::SetBit(&bitmap[0], 121);
+  arrow::bit_util::SetBit(&bitmap[0], 220);
 
   status = selection->PopulateFromBitMap(&bitmap[0], bitmap_size, max_slots - 1);
   EXPECT_EQ(status.ok(), true) << status.message();
@@ -128,9 +128,9 @@ TEST_F(TestSelectionVector, TestInt16PopulateFromBitMapNegative) {
   int bitmap_size = 16;
   std::vector<uint8_t> bitmap(bitmap_size);
 
-  arrow::BitUtil::SetBit(&bitmap[0], 0);
-  arrow::BitUtil::SetBit(&bitmap[0], 1);
-  arrow::BitUtil::SetBit(&bitmap[0], 2);
+  arrow::bit_util::SetBit(&bitmap[0], 0);
+  arrow::bit_util::SetBit(&bitmap[0], 1);
+  arrow::bit_util::SetBit(&bitmap[0], 2);
 
   // The bitmap has three set bits, whereas the selection vector has capacity for only 2.
   status = selection->PopulateFromBitMap(&bitmap[0], bitmap_size, 2);
@@ -175,10 +175,10 @@ TEST_F(TestSelectionVector, TestInt32PopulateFromBitMap) {
   int bitmap_size = RoundUpNumi64(max_slots) * 8;
   std::vector<uint8_t> bitmap(bitmap_size);
 
-  arrow::BitUtil::SetBit(&bitmap[0], 0);
-  arrow::BitUtil::SetBit(&bitmap[0], 5);
-  arrow::BitUtil::SetBit(&bitmap[0], 121);
-  arrow::BitUtil::SetBit(&bitmap[0], 220);
+  arrow::bit_util::SetBit(&bitmap[0], 0);
+  arrow::bit_util::SetBit(&bitmap[0], 5);
+  arrow::bit_util::SetBit(&bitmap[0], 121);
+  arrow::bit_util::SetBit(&bitmap[0], 220);
 
   status = selection->PopulateFromBitMap(&bitmap[0], bitmap_size, max_slots - 1);
   EXPECT_EQ(status.ok(), true) << status.message();
@@ -240,10 +240,10 @@ TEST_F(TestSelectionVector, TestInt64PopulateFromBitMap) {
   int bitmap_size = RoundUpNumi64(max_slots) * 8;
   std::vector<uint8_t> bitmap(bitmap_size);
 
-  arrow::BitUtil::SetBit(&bitmap[0], 0);
-  arrow::BitUtil::SetBit(&bitmap[0], 5);
-  arrow::BitUtil::SetBit(&bitmap[0], 121);
-  arrow::BitUtil::SetBit(&bitmap[0], 220);
+  arrow::bit_util::SetBit(&bitmap[0], 0);
+  arrow::bit_util::SetBit(&bitmap[0], 5);
+  arrow::bit_util::SetBit(&bitmap[0], 121);
+  arrow::bit_util::SetBit(&bitmap[0], 220);
 
   status = selection->PopulateFromBitMap(&bitmap[0], bitmap_size, max_slots - 1);
   EXPECT_EQ(status.ok(), true) << status.message();
diff --git a/cpp/src/gandiva/tests/boolean_expr_test.cc b/cpp/src/gandiva/tests/boolean_expr_test.cc
index 9226f357159..e3224f49983 100644
--- a/cpp/src/gandiva/tests/boolean_expr_test.cc
+++ b/cpp/src/gandiva/tests/boolean_expr_test.cc
@@ -109,6 +109,48 @@ TEST_F(TestBooleanExpr, SimpleAnd) {
   EXPECT_ARROW_ARRAY_EQUALS(exp, outputs.at(0));
 }
 
+TEST_F(TestBooleanExpr, IsTrueFalse) {
+  // schema for input fields
+  auto field_a = field("a", boolean());
+  auto schema = arrow::schema({field_a});
+
+  // output fields
+  auto field_result_1 = field("is_true", boolean());
+  auto field_result_2 = field("is_not_false", boolean());
+  auto field_result_3 = field("is_false", boolean());
+  auto field_result_4 = field("is_not_true", boolean());
+
+  // build expressions.
+  auto is_true = TreeExprBuilder::MakeExpression("istrue", {field_a}, field_result_1);
+  auto is_not_false =
+      TreeExprBuilder::MakeExpression("isnotfalse", {field_a}, field_result_2);
+  auto is_false = TreeExprBuilder::MakeExpression("isfalse", {field_a}, field_result_3);
+  auto is_not_true =
+      TreeExprBuilder::MakeExpression("isnottrue", {field_a}, field_result_4);
+
+  // Build a projector for the expressions.
+  std::shared_ptr<Projector> projector;
+  auto status = Projector::Make(schema, {is_true, is_not_false, is_false, is_not_true},
+                                TestConfiguration(), &projector);
+  EXPECT_TRUE(status.ok());
+
+  int num_records = 4;
+  auto in_a = MakeArrowArrayBool({true, false, false, true}, {true, true, true, true});
+  auto expa = MakeArrowArrayBool({true, false, false, true}, {true, true, true, true});
+  auto expb = MakeArrowArrayBool({true, false, false, true}, {true, true, true, true});
+  auto expc = MakeArrowArrayBool({false, true, true, false}, {true, true, true, true});
+  auto expd = MakeArrowArrayBool({false, true, true, false}, {true, true, true, true});
+  auto in_batch = arrow::RecordBatch::Make(schema, num_records, {in_a});
+
+  arrow::ArrayVector outputs;
+  status = projector->Evaluate(*in_batch, pool_, &outputs);
+  EXPECT_TRUE(status.ok());
+  EXPECT_ARROW_ARRAY_EQUALS(expa, outputs.at(0));
+  EXPECT_ARROW_ARRAY_EQUALS(expb, outputs.at(1));
+  EXPECT_ARROW_ARRAY_EQUALS(expc, outputs.at(2));
+  EXPECT_ARROW_ARRAY_EQUALS(expc, outputs.at(3));
+}
+
 TEST_F(TestBooleanExpr, SimpleOr) {
   // schema for input fields
   auto fielda = field("a", int32());
diff --git a/cpp/src/gandiva/tests/filter_test.cc b/cpp/src/gandiva/tests/filter_test.cc
index d4433f11eb1..871fb2d5da5 100644
--- a/cpp/src/gandiva/tests/filter_test.cc
+++ b/cpp/src/gandiva/tests/filter_test.cc
@@ -29,7 +29,11 @@ using arrow::int32;
 
 class TestFilter : public ::testing::Test {
  public:
-  void SetUp() { pool_ = arrow::default_memory_pool(); }
+  void SetUp() {
+    pool_ = arrow::default_memory_pool();
+    // Setup arrow log severity threshold to debug level.
+    arrow::util::ArrowLog::StartArrowLog("", arrow::util::ArrowLogLevel::ARROW_DEBUG);
+  }
 
  protected:
   arrow::MemoryPool* pool_;
@@ -55,12 +59,13 @@ TEST_F(TestFilter, TestFilterCache) {
   std::shared_ptr<Filter> filter;
   auto status = Filter::Make(schema, condition, configuration, &filter);
   EXPECT_TRUE(status.ok());
+  EXPECT_FALSE(filter->GetBuiltFromCache());
 
   // same schema and condition, should return the same filter as above.
   std::shared_ptr<Filter> cached_filter;
   status = Filter::Make(schema, condition, configuration, &cached_filter);
   EXPECT_TRUE(status.ok());
-  EXPECT_TRUE(cached_filter.get() == filter.get());
+  EXPECT_TRUE(cached_filter->GetBuiltFromCache());
 
   // schema is different should return a new filter.
   auto field2 = field("f2", int32());
@@ -69,7 +74,7 @@ TEST_F(TestFilter, TestFilterCache) {
   status =
       Filter::Make(different_schema, condition, configuration, &should_be_new_filter);
   EXPECT_TRUE(status.ok());
-  EXPECT_TRUE(cached_filter.get() != should_be_new_filter.get());
+  EXPECT_FALSE(should_be_new_filter->GetBuiltFromCache());
 
   // condition is different, should return a new filter.
   auto greater_than_10 = TreeExprBuilder::MakeFunction(
@@ -78,7 +83,7 @@ TEST_F(TestFilter, TestFilterCache) {
   std::shared_ptr<Filter> should_be_new_filter1;
   status = Filter::Make(schema, new_condition, configuration, &should_be_new_filter1);
   EXPECT_TRUE(status.ok());
-  EXPECT_TRUE(cached_filter.get() != should_be_new_filter1.get());
+  EXPECT_FALSE(should_be_new_filter->GetBuiltFromCache());
 }
 
 TEST_F(TestFilter, TestSimple) {
diff --git a/cpp/src/gandiva/tests/projector_test.cc b/cpp/src/gandiva/tests/projector_test.cc
index 7b81f72af3d..9f330a72234 100644
--- a/cpp/src/gandiva/tests/projector_test.cc
+++ b/cpp/src/gandiva/tests/projector_test.cc
@@ -40,7 +40,11 @@ using arrow::int64;
 
 class TestProjector : public ::testing::Test {
  public:
-  void SetUp() { pool_ = arrow::default_memory_pool(); }
+  void SetUp() {
+    pool_ = arrow::default_memory_pool();
+    // Setup arrow log severity threshold to debug level.
+    arrow::util::ArrowLog::StartArrowLog("", arrow::util::ArrowLogLevel::ARROW_DEBUG);
+  }
 
  protected:
   arrow::MemoryPool* pool_;
@@ -66,14 +70,16 @@ TEST_F(TestProjector, TestProjectCache) {
   std::shared_ptr<Projector> projector;
   auto status = Projector::Make(schema, {sum_expr, sub_expr}, configuration, &projector);
   ASSERT_OK(status);
+  EXPECT_FALSE(projector->GetBuiltFromCache());
 
   // everything is same, should return the same projector.
   auto schema_same = arrow::schema({field0, field1});
   std::shared_ptr<Projector> cached_projector;
   status = Projector::Make(schema_same, {sum_expr, sub_expr}, configuration,
                            &cached_projector);
+
   ASSERT_OK(status);
-  EXPECT_EQ(cached_projector, projector);
+  EXPECT_TRUE(cached_projector->GetBuiltFromCache());
 
   // schema is different should return a new projector.
   auto field2 = field("f2", int32());
@@ -82,19 +88,19 @@ TEST_F(TestProjector, TestProjectCache) {
   status = Projector::Make(different_schema, {sum_expr, sub_expr}, configuration,
                            &should_be_new_projector);
   ASSERT_OK(status);
-  EXPECT_NE(cached_projector, should_be_new_projector);
+  EXPECT_FALSE(should_be_new_projector->GetBuiltFromCache());
 
   // expression list is different should return a new projector.
   std::shared_ptr<Projector> should_be_new_projector1;
   status = Projector::Make(schema, {sum_expr}, configuration, &should_be_new_projector1);
   ASSERT_OK(status);
-  EXPECT_NE(cached_projector, should_be_new_projector1);
+  EXPECT_FALSE(should_be_new_projector1->GetBuiltFromCache());
 
   // another instance of the same configuration, should return the same projector.
   status = Projector::Make(schema, {sum_expr, sub_expr}, TestConfiguration(),
                            &cached_projector);
   ASSERT_OK(status);
-  EXPECT_EQ(cached_projector, projector);
+  EXPECT_TRUE(cached_projector->GetBuiltFromCache());
 }
 
 TEST_F(TestProjector, TestProjectCacheFieldNames) {
@@ -197,13 +203,14 @@ TEST_F(TestProjector, TestProjectCacheDecimalCast) {
   auto expr0 = TreeExprBuilder::MakeExpression("castDECIMAL", {field_float64}, res_31_13);
   std::shared_ptr<Projector> projector0;
   ASSERT_OK(Projector::Make(schema, {expr0}, TestConfiguration(), &projector0));
+  EXPECT_FALSE(projector0->GetBuiltFromCache());
 
   // if the output scale is different, the cache can't be used.
   auto res_31_14 = field("result", arrow::decimal(31, 14));
   auto expr1 = TreeExprBuilder::MakeExpression("castDECIMAL", {field_float64}, res_31_14);
   std::shared_ptr<Projector> projector1;
   ASSERT_OK(Projector::Make(schema, {expr1}, TestConfiguration(), &projector1));
-  EXPECT_NE(projector0.get(), projector1.get());
+  EXPECT_FALSE(projector1->GetBuiltFromCache());
 
   // if the output scale/precision are same, should get a cache hit.
   auto res_31_13_alt = field("result", arrow::decimal(31, 13));
@@ -211,7 +218,40 @@ TEST_F(TestProjector, TestProjectCacheDecimalCast) {
       TreeExprBuilder::MakeExpression("castDECIMAL", {field_float64}, res_31_13_alt);
   std::shared_ptr<Projector> projector2;
   ASSERT_OK(Projector::Make(schema, {expr2}, TestConfiguration(), &projector2));
-  EXPECT_EQ(projector0.get(), projector2.get());
+  EXPECT_TRUE(projector2->GetBuiltFromCache());
+}
+
+TEST_F(TestProjector, TestFactorial) {
+  // schema for input fields
+  auto field0 = field("f0", arrow::int64());
+  auto schema = arrow::schema({field0});
+
+  // output fields
+  auto field_fac = field("fact", arrow::int64());
+
+  // Build expression
+  auto fac_expr = TreeExprBuilder::MakeExpression("factorial", {field0}, field_fac);
+
+  std::shared_ptr<Projector> projector;
+  auto status = Projector::Make(schema, {fac_expr}, TestConfiguration(), &projector);
+  EXPECT_TRUE(status.ok());
+
+  // Create a row-batch with some sample data
+  int num_records = 4;
+  auto array0 = MakeArrowArrayInt64({1, 2, 3, 4}, {true, true, true, true});
+  // expected output
+  auto exp_fac = MakeArrowArrayInt64({1, 2, 6, 24}, {true, true, true, true});
+
+  // prepare input record batch
+  auto in_batch = arrow::RecordBatch::Make(schema, num_records, {array0});
+
+  // Evaluate expression
+  arrow::ArrayVector outputs;
+  status = projector->Evaluate(*in_batch, pool_, &outputs);
+  EXPECT_TRUE(status.ok());
+
+  // Validate results
+  EXPECT_ARROW_ARRAY_EQUALS(exp_fac, outputs.at(0));
 }
 
 TEST_F(TestProjector, TestIntSumSub) {
@@ -604,8 +644,8 @@ TEST_F(TestProjector, TestZeroCopy) {
   auto exp = MakeArrowArrayFloat32({1, 2, 3, 0}, {true, true, true, false});
 
   // allocate output buffers
-  int64_t bitmap_sz = arrow::BitUtil::BytesForBits(num_records);
-  int64_t bitmap_capacity = arrow::BitUtil::RoundUpToMultipleOf64(bitmap_sz);
+  int64_t bitmap_sz = arrow::bit_util::BytesForBits(num_records);
+  int64_t bitmap_capacity = arrow::bit_util::RoundUpToMultipleOf64(bitmap_sz);
   std::vector<uint8_t> bitmap(bitmap_capacity);
   std::shared_ptr<arrow::MutableBuffer> bitmap_buf =
       std::make_shared<arrow::MutableBuffer>(&bitmap[0], bitmap_capacity);
@@ -651,7 +691,7 @@ TEST_F(TestProjector, TestZeroCopyNegative) {
   auto exp = MakeArrowArrayFloat32({1, 2, 3, 0}, {true, true, true, false});
 
   // allocate output buffers
-  int64_t bitmap_sz = arrow::BitUtil::BytesForBits(num_records);
+  int64_t bitmap_sz = arrow::bit_util::BytesForBits(num_records);
   std::unique_ptr<uint8_t[]> bitmap(new uint8_t[bitmap_sz]);
   std::shared_ptr<arrow::MutableBuffer> bitmap_buf =
       std::make_shared<arrow::MutableBuffer>(bitmap.get(), bitmap_sz);
@@ -850,6 +890,60 @@ TEST_F(TestProjector, TestPmod) {
   EXPECT_ARROW_ARRAY_EQUALS(exp_pmod, outputs.at(0));
 }
 
+TEST_F(TestProjector, TestGreatestLeast) {
+  // schema for input fields
+  auto f0 = field("f0", int32());
+  auto f1 = field("f1", int32());
+  auto f2 = field("f2", int32());
+  auto schema = arrow::schema({f0, f1, f2});
+
+  // output fields
+  auto field_greatest = field("greatest", int32());
+  auto field_least = field("least", int32());
+
+  // Build expression
+  auto greatest_expr =
+      TreeExprBuilder::MakeExpression("greatest", {f0, f1, f2}, field_greatest);
+
+  std::shared_ptr<Projector> projector;
+  auto status = Projector::Make(schema, {greatest_expr}, TestConfiguration(), &projector);
+  EXPECT_TRUE(status.ok()) << status.message();
+
+  // Create a row-batch with some sample data
+  int num_records = 4;
+  auto a0 = MakeArrowArrayInt32({10, 20, 30, 40}, {true, true, true, true});
+  auto a1 = MakeArrowArrayInt32({2, 8, 50, 25}, {true, true, true, true});
+  auto a2 = MakeArrowArrayInt32({526, 32, 9, -5}, {true, true, true, true});
+  // expected output
+  auto exp_greatest = MakeArrowArrayInt32({526, 32, 50, 40}, {true, true, true, true});
+  auto exp_least = MakeArrowArrayInt32({2, 8, 9, -5}, {true, true, true, true});
+
+  // GREATEST
+  // prepare input record batch
+  auto in_batch = arrow::RecordBatch::Make(schema, num_records, {a0, a1, a2});
+  // Evaluate expression
+  arrow::ArrayVector outputs_grt;
+  status = projector->Evaluate(*in_batch, pool_, &outputs_grt);
+  EXPECT_TRUE(status.ok()) << status.message();
+
+  // Validate results
+  EXPECT_ARROW_ARRAY_EQUALS(exp_greatest, outputs_grt.at(0));
+
+  // LEAST
+  // Reproduce the same test now for the least operator
+  auto least_expr = TreeExprBuilder::MakeExpression("least", {f0, f1, f2}, field_least);
+  status = Projector::Make(schema, {least_expr}, TestConfiguration(), &projector);
+  EXPECT_TRUE(status.ok()) << status.message();
+
+  // Evaluate expression
+  arrow::ArrayVector outputs_lst;
+  status = projector->Evaluate(*in_batch, pool_, &outputs_lst);
+  EXPECT_TRUE(status.ok()) << status.message();
+
+  // Validate results
+  EXPECT_ARROW_ARRAY_EQUALS(exp_least, outputs_lst.at(0));
+}
+
 TEST_F(TestProjector, TestConcat) {
   // schema for input fields
   auto field0 = field("f0", arrow::utf8());
@@ -889,6 +983,49 @@ TEST_F(TestProjector, TestConcat) {
   EXPECT_ARROW_ARRAY_EQUALS(exp_concat, outputs.at(0));
 }
 
+TEST_F(TestProjector, TestLevenshtein) {
+  // schema for input fields
+  auto f0 = field("f0", arrow::utf8());
+  auto f1 = field("f1", arrow::utf8());
+  auto schema = arrow::schema({f0, f1});
+
+  // output fields
+  auto field_lev = field("levenshtein", arrow::int32());
+
+  // Build expression
+  auto lev_expr = TreeExprBuilder::MakeExpression("levenshtein", {f0, f1}, field_lev);
+
+  std::shared_ptr<Projector> projector;
+  auto status = Projector::Make(schema, {lev_expr}, TestConfiguration(), &projector);
+  EXPECT_TRUE(status.ok()) << status.message();
+
+  // Create a row-batch with some sample data
+  int num_records = 10;
+  auto array0 =
+      MakeArrowArrayUtf8({"cat", "task", "", "a", "a", "Test String1", "TEST STRING1",
+                          "Test String1", "", ""},
+                         {true, true, true, true, true, true, true, true, true, true});
+  auto array1 =
+      MakeArrowArrayUtf8({"coat", "test", "a", "", "abbbbbbbbbb", "Test String2",
+                          "test string2", "", "Test String2", ""},
+                         {true, true, true, true, true, true, true, true, true, true});
+  // expected output
+  auto exp_lev =
+      MakeArrowArrayInt32({1, 2, 1, 1, 10, 1, 11, 12, 12, 0},
+                          {true, true, true, true, true, true, true, true, true, true});
+
+  // prepare input record batch
+  auto in_batch = arrow::RecordBatch::Make(schema, num_records, {array0, array1});
+
+  // Evaluate expression
+  arrow::ArrayVector outputs;
+  status = projector->Evaluate(*in_batch, pool_, &outputs);
+  EXPECT_TRUE(status.ok()) << status.message();
+
+  // Validate results
+  EXPECT_ARROW_ARRAY_EQUALS(exp_lev, outputs.at(0));
+}
+
 TEST_F(TestProjector, TestQuote) {
   // schema for input fields
   auto field0 = field("f0", arrow::utf8());
diff --git a/cpp/src/parquet/arrow/reader.cc b/cpp/src/parquet/arrow/reader.cc
index 1c233186472..3b0b622e925 100644
--- a/cpp/src/parquet/arrow/reader.cc
+++ b/cpp/src/parquet/arrow/reader.cc
@@ -72,7 +72,7 @@ using ParquetReader = parquet::ParquetFileReader;
 
 using parquet::internal::RecordReader;
 
-namespace BitUtil = arrow::BitUtil;
+namespace bit_util = arrow::bit_util;
 
 namespace parquet {
 namespace arrow {
@@ -583,9 +583,9 @@ class ListReader : public ColumnReaderImpl {
     ::parquet::internal::ValidityBitmapInputOutput validity_io;
     validity_io.values_read_upper_bound = length_upper_bound;
     if (field_->nullable()) {
-      ARROW_ASSIGN_OR_RAISE(
-          validity_buffer,
-          AllocateResizableBuffer(BitUtil::BytesForBits(length_upper_bound), ctx_->pool));
+      ARROW_ASSIGN_OR_RAISE(validity_buffer,
+                            AllocateResizableBuffer(
+                                bit_util::BytesForBits(length_upper_bound), ctx_->pool));
       validity_io.valid_bits = validity_buffer->mutable_data();
     }
     ARROW_ASSIGN_OR_RAISE(
@@ -609,7 +609,7 @@ class ListReader : public ColumnReaderImpl {
         offsets_buffer->Resize((validity_io.values_read + 1) * sizeof(IndexType)));
     if (validity_buffer != nullptr) {
       RETURN_NOT_OK(
-          validity_buffer->Resize(BitUtil::BytesForBits(validity_io.values_read)));
+          validity_buffer->Resize(bit_util::BytesForBits(validity_io.values_read)));
       validity_buffer->ZeroPadding();
     }
     ARROW_ASSIGN_OR_RAISE(std::shared_ptr<ArrayData> item_chunk, ChunksToSingle(**out));
@@ -757,7 +757,7 @@ Status StructReader::BuildArray(int64_t length_upper_bound,
   if (has_repeated_child_) {
     ARROW_ASSIGN_OR_RAISE(
         null_bitmap,
-        AllocateResizableBuffer(BitUtil::BytesForBits(length_upper_bound), ctx_->pool));
+        AllocateResizableBuffer(bit_util::BytesForBits(length_upper_bound), ctx_->pool));
     validity_io.valid_bits = null_bitmap->mutable_data();
     RETURN_NOT_OK(GetDefLevels(&def_levels, &num_levels));
     RETURN_NOT_OK(GetRepLevels(&rep_levels, &num_levels));
@@ -765,7 +765,7 @@ Status StructReader::BuildArray(int64_t length_upper_bound,
   } else if (filtered_field_->nullable()) {
     ARROW_ASSIGN_OR_RAISE(
         null_bitmap,
-        AllocateResizableBuffer(BitUtil::BytesForBits(length_upper_bound), ctx_->pool));
+        AllocateResizableBuffer(bit_util::BytesForBits(length_upper_bound), ctx_->pool));
     validity_io.valid_bits = null_bitmap->mutable_data();
     RETURN_NOT_OK(GetDefLevels(&def_levels, &num_levels));
     DefLevelsToBitmap(def_levels, num_levels, level_info_, &validity_io);
@@ -773,7 +773,7 @@ Status StructReader::BuildArray(int64_t length_upper_bound,
 
   // Ensure all values are initialized.
   if (null_bitmap) {
-    RETURN_NOT_OK(null_bitmap->Resize(BitUtil::BytesForBits(validity_io.values_read)));
+    RETURN_NOT_OK(null_bitmap->Resize(bit_util::BytesForBits(validity_io.values_read)));
     null_bitmap->ZeroPadding();
   }
 
diff --git a/cpp/src/parquet/arrow/reader_internal.cc b/cpp/src/parquet/arrow/reader_internal.cc
index 62e6579dddc..f1f3cb114a6 100644
--- a/cpp/src/parquet/arrow/reader_internal.cc
+++ b/cpp/src/parquet/arrow/reader_internal.cc
@@ -78,7 +78,7 @@ using arrow::StructArray;
 using arrow::Table;
 using arrow::TimestampArray;
 
-using ::arrow::BitUtil::FromBigEndian;
+using ::arrow::bit_util::FromBigEndian;
 using ::arrow::internal::checked_cast;
 using ::arrow::internal::checked_pointer_cast;
 using ::arrow::internal::SafeLeftShift;
@@ -92,7 +92,7 @@ using parquet::schema::Node;
 using parquet::schema::PrimitiveNode;
 using ParquetType = parquet::Type;
 
-namespace BitUtil = arrow::BitUtil;
+namespace bit_util = arrow::bit_util;
 
 namespace parquet {
 namespace arrow {
@@ -332,7 +332,7 @@ std::shared_ptr<Array> TransferZeroCopy(RecordReader* reader,
 Status TransferBool(RecordReader* reader, MemoryPool* pool, Datum* out) {
   int64_t length = reader->values_written();
 
-  const int64_t buffer_size = BitUtil::BytesForBits(length);
+  const int64_t buffer_size = bit_util::BytesForBits(length);
   ARROW_ASSIGN_OR_RAISE(auto data, ::arrow::AllocateBuffer(buffer_size, pool));
 
   // Transfer boolean values to packed bitmap
@@ -342,7 +342,7 @@ Status TransferBool(RecordReader* reader, MemoryPool* pool, Datum* out) {
 
   for (int64_t i = 0; i < length; i++) {
     if (values[i]) {
-      ::arrow::BitUtil::SetBit(data_ptr, i);
+      ::arrow::bit_util::SetBit(data_ptr, i);
     }
   }
 
@@ -612,7 +612,7 @@ static Status DecimalIntegerTransfer(RecordReader* reader, MemoryPool* pool,
   ARROW_ASSIGN_OR_RAISE(auto data, ::arrow::AllocateBuffer(length * type_length, pool));
   uint8_t* out_ptr = data->mutable_data();
 
-  using ::arrow::BitUtil::FromLittleEndian;
+  using ::arrow::bit_util::FromLittleEndian;
 
   for (int64_t i = 0; i < length; ++i, out_ptr += type_length) {
     // sign/zero extend int32_t values, otherwise a no-op
diff --git a/cpp/src/parquet/arrow/reconstruct_internal_test.cc b/cpp/src/parquet/arrow/reconstruct_internal_test.cc
index 495b69f9eab..9254e774b3e 100644
--- a/cpp/src/parquet/arrow/reconstruct_internal_test.cc
+++ b/cpp/src/parquet/arrow/reconstruct_internal_test.cc
@@ -113,9 +113,10 @@ class FileBuilder {
     auto typed_writer =
         checked_cast<TypedColumnWriter<PhysicalType<TYPE>>*>(column_writer);
 
-    const int64_t num_values = static_cast<int64_t>(
-        (max_def_level > 0) ? def_levels.size()
-                            : (max_rep_level > 0) ? rep_levels.size() : values.size());
+    const int64_t num_values =
+        static_cast<int64_t>((max_def_level > 0)   ? def_levels.size()
+                             : (max_rep_level > 0) ? rep_levels.size()
+                                                   : values.size());
     const int64_t values_written = typed_writer->WriteBatch(
         num_values, LevelPointerOrNull(def_levels, max_def_level),
         LevelPointerOrNull(rep_levels, max_rep_level), values.data());
diff --git a/cpp/src/parquet/arrow/test_util.h b/cpp/src/parquet/arrow/test_util.h
index a70185f709d..495b6ebba27 100644
--- a/cpp/src/parquet/arrow/test_util.h
+++ b/cpp/src/parquet/arrow/test_util.h
@@ -411,7 +411,7 @@ Status MakeListArray(const std::shared_ptr<Array>& values, int64_t size,
   int32_t* offsets_ptr = reinterpret_cast<int32_t*>(offsets->mutable_data());
 
   auto null_bitmap = AllocateBuffer();
-  int64_t bitmap_size = ::arrow::BitUtil::BytesForBits(size);
+  int64_t bitmap_size = ::arrow::bit_util::BytesForBits(size);
   RETURN_NOT_OK(null_bitmap->Resize(bitmap_size));
   uint8_t* null_bitmap_ptr = null_bitmap->mutable_data();
   memset(null_bitmap_ptr, 0, bitmap_size);
@@ -421,7 +421,7 @@ Status MakeListArray(const std::shared_ptr<Array>& values, int64_t size,
     offsets_ptr[i] = current_offset;
     if (!(((i % 2) == 0) && ((i / 2) < null_count))) {
       // Non-null list (list with index 1 is always empty).
-      ::arrow::BitUtil::SetBit(null_bitmap_ptr, i);
+      ::arrow::bit_util::SetBit(null_bitmap_ptr, i);
       if (i != 1) {
         current_offset += static_cast<int32_t>(length_per_entry);
       }
diff --git a/cpp/src/parquet/bloom_filter.cc b/cpp/src/parquet/bloom_filter.cc
index f6f6d327d06..302698836b5 100644
--- a/cpp/src/parquet/bloom_filter.cc
+++ b/cpp/src/parquet/bloom_filter.cc
@@ -39,7 +39,7 @@ void BlockSplitBloomFilter::Init(uint32_t num_bytes) {
 
   // Get next power of 2 if it is not power of 2.
   if ((num_bytes & (num_bytes - 1)) != 0) {
-    num_bytes = static_cast<uint32_t>(::arrow::BitUtil::NextPower2(num_bytes));
+    num_bytes = static_cast<uint32_t>(::arrow::bit_util::NextPower2(num_bytes));
   }
 
   if (num_bytes > kMaximumBloomFilterBytes) {
diff --git a/cpp/src/parquet/bloom_filter.h b/cpp/src/parquet/bloom_filter.h
index 39f9561ae5b..4d12a7c63b6 100644
--- a/cpp/src/parquet/bloom_filter.h
+++ b/cpp/src/parquet/bloom_filter.h
@@ -169,7 +169,7 @@ class PARQUET_EXPORT BlockSplitBloomFilter : public BloomFilter {
 
     // Get next power of 2 if bits is not power of 2.
     if ((num_bits & (num_bits - 1)) != 0) {
-      num_bits = static_cast<uint32_t>(::arrow::BitUtil::NextPower2(num_bits));
+      num_bits = static_cast<uint32_t>(::arrow::bit_util::NextPower2(num_bits));
     }
 
     // Round down to upper bound
diff --git a/cpp/src/parquet/column_reader.cc b/cpp/src/parquet/column_reader.cc
index 8d0abe122bb..cab276b5ef9 100644
--- a/cpp/src/parquet/column_reader.cc
+++ b/cpp/src/parquet/column_reader.cc
@@ -57,7 +57,7 @@ using arrow::internal::AddWithOverflow;
 using arrow::internal::checked_cast;
 using arrow::internal::MultiplyWithOverflow;
 
-namespace BitUtil = arrow::BitUtil;
+namespace bit_util = arrow::bit_util;
 
 namespace parquet {
 namespace {
@@ -91,7 +91,7 @@ int LevelDecoder::SetData(Encoding::type encoding, int16_t max_level,
   int32_t num_bytes = 0;
   encoding_ = encoding;
   num_values_remaining_ = num_buffered_values;
-  bit_width_ = BitUtil::Log2(max_level + 1);
+  bit_width_ = bit_util::Log2(max_level + 1);
   switch (encoding) {
     case Encoding::RLE: {
       if (data_size < 4) {
@@ -116,12 +116,12 @@ int LevelDecoder::SetData(Encoding::type encoding, int16_t max_level,
         throw ParquetException(
             "Number of buffered values too large (corrupt data page?)");
       }
-      num_bytes = static_cast<int32_t>(BitUtil::BytesForBits(num_bits));
+      num_bytes = static_cast<int32_t>(bit_util::BytesForBits(num_bits));
       if (num_bytes < 0 || num_bytes > data_size - 4) {
         throw ParquetException("Received invalid number of bytes (corrupt data page?)");
       }
       if (!bit_packed_decoder_) {
-        bit_packed_decoder_.reset(new ::arrow::BitUtil::BitReader(data, num_bytes));
+        bit_packed_decoder_.reset(new ::arrow::bit_util::BitReader(data, num_bytes));
       } else {
         bit_packed_decoder_->Reset(data, num_bytes);
       }
@@ -143,7 +143,7 @@ void LevelDecoder::SetDataV2(int32_t num_bytes, int16_t max_level,
   }
   encoding_ = Encoding::RLE;
   num_values_remaining_ = num_buffered_values;
-  bit_width_ = BitUtil::Log2(max_level + 1);
+  bit_width_ = bit_util::Log2(max_level + 1);
 
   if (!rle_decoder_) {
     rle_decoder_.reset(new ::arrow::util::RleDecoder(data, num_bytes, bit_width_));
@@ -1039,9 +1039,9 @@ int64_t TypedColumnReaderImpl<DType>::ReadBatchSpaced(
         }
       }
       total_values = this->ReadValues(values_to_read, values);
-      ::arrow::BitUtil::SetBitsTo(valid_bits, valid_bits_offset,
-                                  /*length=*/total_values,
-                                  /*bits_are_set=*/true);
+      ::arrow::bit_util::SetBitsTo(valid_bits, valid_bits_offset,
+                                   /*length=*/total_values,
+                                   /*bits_are_set=*/true);
       *values_read = total_values;
     } else {
       internal::LevelInfo info;
@@ -1069,9 +1069,9 @@ int64_t TypedColumnReaderImpl<DType>::ReadBatchSpaced(
   } else {
     // Required field, read all values
     total_values = this->ReadValues(batch_size, values);
-    ::arrow::BitUtil::SetBitsTo(valid_bits, valid_bits_offset,
-                                /*length=*/total_values,
-                                /*bits_are_set=*/true);
+    ::arrow::bit_util::SetBitsTo(valid_bits, valid_bits_offset,
+                                 /*length=*/total_values,
+                                 /*bits_are_set=*/true);
     *null_count_out = 0;
     *values_read = total_values;
     *levels_read = total_values;
@@ -1297,7 +1297,7 @@ class TypedRecordReader : public ColumnReaderImplBase<DType>,
   std::shared_ptr<ResizableBuffer> ReleaseIsValid() override {
     if (leaf_info_.HasNullableValues()) {
       auto result = valid_bits_;
-      PARQUET_THROW_NOT_OK(result->Resize(BitUtil::BytesForBits(values_written_), true));
+      PARQUET_THROW_NOT_OK(result->Resize(bit_util::BytesForBits(values_written_), true));
       valid_bits_ = AllocateBuffer(this->pool_);
       return result;
     } else {
@@ -1371,7 +1371,7 @@ class TypedRecordReader : public ColumnReaderImplBase<DType>,
     if (capacity >= target_size) {
       return capacity;
     }
-    return BitUtil::NextPower2(target_size);
+    return bit_util::NextPower2(target_size);
   }
 
   void ReserveLevels(int64_t extra_levels) {
@@ -1406,9 +1406,9 @@ class TypedRecordReader : public ColumnReaderImplBase<DType>,
       values_capacity_ = new_values_capacity;
     }
     if (leaf_info_.HasNullableValues()) {
-      int64_t valid_bytes_new = BitUtil::BytesForBits(values_capacity_);
+      int64_t valid_bytes_new = bit_util::BytesForBits(values_capacity_);
       if (valid_bits_->size() < valid_bytes_new) {
-        int64_t valid_bytes_old = BitUtil::BytesForBits(values_written_);
+        int64_t valid_bytes_old = bit_util::BytesForBits(values_written_);
         PARQUET_THROW_NOT_OK(valid_bits_->Resize(valid_bytes_new, false));
 
         // Avoid valgrind warnings
@@ -1619,7 +1619,7 @@ class FLBARecordReader : public TypedRecordReader<FLBAType>,
     DCHECK_EQ(num_decoded, values_to_read);
 
     for (int64_t i = 0; i < num_decoded; i++) {
-      if (::arrow::BitUtil::GetBit(valid_bits, valid_bits_offset + i)) {
+      if (::arrow::bit_util::GetBit(valid_bits, valid_bits_offset + i)) {
         PARQUET_THROW_NOT_OK(builder_->Append(values[i].ptr));
       } else {
         PARQUET_THROW_NOT_OK(builder_->AppendNull());
diff --git a/cpp/src/parquet/column_reader.h b/cpp/src/parquet/column_reader.h
index 8c48e4d7843..50eac31dc3e 100644
--- a/cpp/src/parquet/column_reader.h
+++ b/cpp/src/parquet/column_reader.h
@@ -33,9 +33,9 @@ namespace arrow {
 class Array;
 class ChunkedArray;
 
-namespace BitUtil {
+namespace bit_util {
 class BitReader;
-}  // namespace BitUtil
+}  // namespace bit_util
 
 namespace util {
 class RleDecoder;
@@ -75,7 +75,7 @@ class PARQUET_EXPORT LevelDecoder {
   int num_values_remaining_;
   Encoding::type encoding_;
   std::unique_ptr<::arrow::util::RleDecoder> rle_decoder_;
-  std::unique_ptr<::arrow::BitUtil::BitReader> bit_packed_decoder_;
+  std::unique_ptr<::arrow::bit_util::BitReader> bit_packed_decoder_;
   int16_t max_level_;
 };
 
diff --git a/cpp/src/parquet/column_writer.cc b/cpp/src/parquet/column_writer.cc
index df535bcbe98..6ac33d90a32 100644
--- a/cpp/src/parquet/column_writer.cc
+++ b/cpp/src/parquet/column_writer.cc
@@ -60,12 +60,12 @@ using arrow::ArrayData;
 using arrow::Datum;
 using arrow::Result;
 using arrow::Status;
-using arrow::BitUtil::BitWriter;
+using arrow::bit_util::BitWriter;
 using arrow::internal::checked_cast;
 using arrow::internal::checked_pointer_cast;
 using arrow::util::RleEncoder;
 
-namespace BitUtil = arrow::BitUtil;
+namespace bit_util = arrow::bit_util;
 
 namespace parquet {
 
@@ -106,9 +106,9 @@ struct ValueBufferSlicer {
 
   Status Visit(const ::arrow::BooleanArray& array) {
     auto data = array.data();
-    if (BitUtil::IsMultipleOf8(data->offset)) {
-      buffer_ = SliceBuffer(data->buffers[1], BitUtil::BytesForBits(data->offset),
-                            BitUtil::BytesForBits(data->length));
+    if (bit_util::IsMultipleOf8(data->offset)) {
+      buffer_ = SliceBuffer(data->buffers[1], bit_util::BytesForBits(data->offset),
+                            bit_util::BytesForBits(data->length));
       return Status::OK();
     }
     PARQUET_ASSIGN_OR_THROW(buffer_,
@@ -168,7 +168,7 @@ LevelEncoder::~LevelEncoder() {}
 
 void LevelEncoder::Init(Encoding::type encoding, int16_t max_level,
                         int num_buffered_values, uint8_t* data, int data_size) {
-  bit_width_ = BitUtil::Log2(max_level + 1);
+  bit_width_ = bit_util::Log2(max_level + 1);
   encoding_ = encoding;
   switch (encoding) {
     case Encoding::RLE: {
@@ -177,7 +177,7 @@ void LevelEncoder::Init(Encoding::type encoding, int16_t max_level,
     }
     case Encoding::BIT_PACKED: {
       int num_bytes =
-          static_cast<int>(BitUtil::BytesForBits(num_buffered_values * bit_width_));
+          static_cast<int>(bit_util::BytesForBits(num_buffered_values * bit_width_));
       bit_packed_encoder_.reset(new BitWriter(data, num_bytes));
       break;
     }
@@ -188,7 +188,7 @@ void LevelEncoder::Init(Encoding::type encoding, int16_t max_level,
 
 int LevelEncoder::MaxBufferSize(Encoding::type encoding, int16_t max_level,
                                 int num_buffered_values) {
-  int bit_width = BitUtil::Log2(max_level + 1);
+  int bit_width = bit_util::Log2(max_level + 1);
   int num_bytes = 0;
   switch (encoding) {
     case Encoding::RLE: {
@@ -200,7 +200,7 @@ int LevelEncoder::MaxBufferSize(Encoding::type encoding, int16_t max_level,
     }
     case Encoding::BIT_PACKED: {
       num_bytes =
-          static_cast<int>(BitUtil::BytesForBits(num_buffered_values * bit_width));
+          static_cast<int>(bit_util::BytesForBits(num_buffered_values * bit_width));
       break;
     }
     default:
@@ -1130,7 +1130,7 @@ class TypedColumnWriterImpl : public ColumnWriterImpl, public TypedColumnWriter<
       ARROW_ASSIGN_OR_RAISE(
           bits_buffer_,
           ::arrow::AllocateResizableBuffer(
-              BitUtil::BytesForBits(properties_->write_batch_size()), ctx->memory_pool));
+              bit_util::BytesForBits(properties_->write_batch_size()), ctx->memory_pool));
       bits_buffer_->ZeroPadding();
     }
 
@@ -1290,7 +1290,7 @@ class TypedColumnWriterImpl : public ColumnWriterImpl, public TypedColumnWriter<
     }
     // Shrink to fit possible causes another allocation, and would only be necessary
     // on the last batch.
-    int64_t new_bitmap_size = BitUtil::BytesForBits(batch_size);
+    int64_t new_bitmap_size = bit_util::BytesForBits(batch_size);
     if (new_bitmap_size != bits_buffer_->size()) {
       PARQUET_THROW_NOT_OK(
           bits_buffer_->Resize(new_bitmap_size, /*shrink_to_fit=*/false));
@@ -2026,13 +2026,13 @@ struct SerializeFunctor<ParquetType, ArrowType, ::arrow::enable_if_decimal<Arrow
     static_assert(byte_width == 16 || byte_width == 32,
                   "only 16 and 32 byte Decimals supported");
     if (byte_width == 32) {
-      *scratch++ = ::arrow::BitUtil::ToBigEndian(u64_in[3]);
-      *scratch++ = ::arrow::BitUtil::ToBigEndian(u64_in[2]);
-      *scratch++ = ::arrow::BitUtil::ToBigEndian(u64_in[1]);
-      *scratch++ = ::arrow::BitUtil::ToBigEndian(u64_in[0]);
+      *scratch++ = ::arrow::bit_util::ToBigEndian(u64_in[3]);
+      *scratch++ = ::arrow::bit_util::ToBigEndian(u64_in[2]);
+      *scratch++ = ::arrow::bit_util::ToBigEndian(u64_in[1]);
+      *scratch++ = ::arrow::bit_util::ToBigEndian(u64_in[0]);
     } else {
-      *scratch++ = ::arrow::BitUtil::ToBigEndian(u64_in[1]);
-      *scratch++ = ::arrow::BitUtil::ToBigEndian(u64_in[0]);
+      *scratch++ = ::arrow::bit_util::ToBigEndian(u64_in[1]);
+      *scratch++ = ::arrow::bit_util::ToBigEndian(u64_in[0]);
     }
     return FixedLenByteArray(out);
   }
diff --git a/cpp/src/parquet/column_writer.h b/cpp/src/parquet/column_writer.h
index 0a609021739..70488326288 100644
--- a/cpp/src/parquet/column_writer.h
+++ b/cpp/src/parquet/column_writer.h
@@ -29,9 +29,9 @@ namespace arrow {
 
 class Array;
 
-namespace BitUtil {
+namespace bit_util {
 class BitWriter;
-}  // namespace BitUtil
+}  // namespace bit_util
 
 namespace util {
 class RleEncoder;
@@ -76,7 +76,7 @@ class PARQUET_EXPORT LevelEncoder {
   int rle_length_;
   Encoding::type encoding_;
   std::unique_ptr<::arrow::util::RleEncoder> rle_encoder_;
-  std::unique_ptr<::arrow::BitUtil::BitWriter> bit_packed_encoder_;
+  std::unique_ptr<::arrow::bit_util::BitWriter> bit_packed_encoder_;
 };
 
 class PARQUET_EXPORT PageWriter {
diff --git a/cpp/src/parquet/column_writer_test.cc b/cpp/src/parquet/column_writer_test.cc
index 42920831413..61f4c47e780 100644
--- a/cpp/src/parquet/column_writer_test.cc
+++ b/cpp/src/parquet/column_writer_test.cc
@@ -36,7 +36,7 @@
 #include "parquet/thrift_internal.h"
 #include "parquet/types.h"
 
-namespace BitUtil = arrow::BitUtil;
+namespace bit_util = arrow::bit_util;
 
 namespace parquet {
 
@@ -234,7 +234,7 @@ class TestPrimitiveWriter : public PrimitiveTypedTest<TestType> {
                                        bool enable_dictionary, bool enable_statistics,
                                        int64_t num_rows, int compression_level) {
     std::vector<uint8_t> valid_bits(
-        BitUtil::BytesForBits(static_cast<uint32_t>(this->values_.size())) + 1, 255);
+        bit_util::BytesForBits(static_cast<uint32_t>(this->values_.size())) + 1, 255);
     ColumnProperties column_properties(encoding, compression, enable_dictionary,
                                        enable_statistics);
     column_properties.set_compression_level(compression_level);
@@ -548,12 +548,12 @@ TYPED_TEST(TestPrimitiveWriter, OptionalSpaced) {
 
   this->GenerateData(SMALL_SIZE);
   std::vector<int16_t> definition_levels(SMALL_SIZE, 1);
-  std::vector<uint8_t> valid_bits(::arrow::BitUtil::BytesForBits(SMALL_SIZE), 255);
+  std::vector<uint8_t> valid_bits(::arrow::bit_util::BytesForBits(SMALL_SIZE), 255);
 
   definition_levels[SMALL_SIZE - 1] = 0;
-  ::arrow::BitUtil::ClearBit(valid_bits.data(), SMALL_SIZE - 1);
+  ::arrow::bit_util::ClearBit(valid_bits.data(), SMALL_SIZE - 1);
   definition_levels[1] = 0;
-  ::arrow::BitUtil::ClearBit(valid_bits.data(), 1);
+  ::arrow::bit_util::ClearBit(valid_bits.data(), 1);
 
   auto writer = this->BuildWriter();
   writer->WriteBatchSpaced(this->values_.size(), definition_levels.data(), nullptr,
diff --git a/cpp/src/parquet/encoding.cc b/cpp/src/parquet/encoding.cc
index 3e0d6b266de..f5b2ca73be4 100644
--- a/cpp/src/parquet/encoding.cc
+++ b/cpp/src/parquet/encoding.cc
@@ -50,7 +50,7 @@
 #include "parquet/schema.h"
 #include "parquet/types.h"
 
-namespace BitUtil = arrow::BitUtil;
+namespace bit_util = arrow::bit_util;
 
 using arrow::Status;
 using arrow::VisitNullBitmapInline;
@@ -341,12 +341,12 @@ class PlainEncoder<BooleanType> : public EncoderImpl, virtual public BooleanEnco
 
     const auto& data = checked_cast<const ::arrow::BooleanArray&>(values);
     if (data.null_count() == 0) {
-      PARQUET_THROW_NOT_OK(sink_.Reserve(BitUtil::BytesForBits(data.length())));
+      PARQUET_THROW_NOT_OK(sink_.Reserve(bit_util::BytesForBits(data.length())));
       // no nulls, just dump the data
       ::arrow::internal::CopyBitmap(data.data()->GetValues<uint8_t>(1), data.offset(),
                                     data.length(), sink_.mutable_data(), sink_.length());
     } else {
-      auto n_valid = BitUtil::BytesForBits(data.length() - data.null_count());
+      auto n_valid = bit_util::BytesForBits(data.length() - data.null_count());
       PARQUET_THROW_NOT_OK(sink_.Reserve(n_valid));
       ::arrow::internal::FirstTimeBitmapWriter writer(sink_.mutable_data(),
                                                       sink_.length(), n_valid);
@@ -370,7 +370,7 @@ class PlainEncoder<BooleanType> : public EncoderImpl, virtual public BooleanEnco
   int bits_available_;
   std::shared_ptr<ResizableBuffer> bits_buffer_;
   ::arrow::BufferBuilder sink_;
-  ::arrow::BitUtil::BitWriter bit_writer_;
+  ::arrow::bit_util::BitWriter bit_writer_;
 
   template <typename SequenceType>
   void PutImpl(const SequenceType& src, int num_values);
@@ -524,7 +524,7 @@ class DictEncoderImpl : public EncoderImpl, virtual public DictEncoder<DType> {
   int bit_width() const override {
     if (ARROW_PREDICT_FALSE(num_entries() == 0)) return 0;
     if (ARROW_PREDICT_FALSE(num_entries() == 1)) return 1;
-    return BitUtil::Log2(num_entries());
+    return bit_util::Log2(num_entries());
   }
 
   /// Encode value. Note that this does not actually write any data, just
@@ -1165,7 +1165,7 @@ class PlainBooleanDecoder : public DecoderImpl,
                   typename EncodingTraits<BooleanType>::DictAccumulator* out) override;
 
  private:
-  std::unique_ptr<::arrow::BitUtil::BitReader> bit_reader_;
+  std::unique_ptr<::arrow::bit_util::BitReader> bit_reader_;
 };
 
 PlainBooleanDecoder::PlainBooleanDecoder(const ColumnDescriptor* descr)
@@ -1173,7 +1173,7 @@ PlainBooleanDecoder::PlainBooleanDecoder(const ColumnDescriptor* descr)
 
 void PlainBooleanDecoder::SetData(int num_values, const uint8_t* data, int len) {
   num_values_ = num_values;
-  bit_reader_.reset(new BitUtil::BitReader(data, len));
+  bit_reader_.reset(new bit_util::BitReader(data, len));
 }
 
 int PlainBooleanDecoder::DecodeArrow(
@@ -1936,7 +1936,7 @@ class DictByteArrayDecoderImpl : public DictDecoderImpl<ByteArrayType>,
         }
       } else {
         for (int64_t i = 0; i < block.length; ++i, ++position) {
-          if (BitUtil::GetBit(valid_bits, valid_bits_offset + position)) {
+          if (bit_util::GetBit(valid_bits, valid_bits_offset + position)) {
             ARROW_RETURN_NOT_OK(visit_valid(position));
           } else {
             ARROW_RETURN_NOT_OK(visit_null());
@@ -2080,13 +2080,13 @@ class DeltaBitPackDecoder : public DecoderImpl, virtual public TypedDecoder<DTyp
   void SetData(int num_values, const uint8_t* data, int len) override {
     // num_values is equal to page's num_values, including null values in this page
     this->num_values_ = num_values;
-    decoder_ = std::make_shared<::arrow::BitUtil::BitReader>(data, len);
+    decoder_ = std::make_shared<::arrow::bit_util::BitReader>(data, len);
     InitHeader();
   }
 
   // Set BitReader which is already initialized by DeltaLengthByteArrayDecoder or
   // DeltaByteArrayDecoder
-  void SetDecoder(int num_values, std::shared_ptr<::arrow::BitUtil::BitReader> decoder) {
+  void SetDecoder(int num_values, std::shared_ptr<::arrow::bit_util::BitReader> decoder) {
     this->num_values_ = num_values;
     decoder_ = decoder;
     InitHeader();
@@ -2236,7 +2236,7 @@ class DeltaBitPackDecoder : public DecoderImpl, virtual public TypedDecoder<DTyp
   }
 
   MemoryPool* pool_;
-  std::shared_ptr<::arrow::BitUtil::BitReader> decoder_;
+  std::shared_ptr<::arrow::bit_util::BitReader> decoder_;
   uint32_t values_per_block_;
   uint32_t mini_blocks_per_block_;
   uint32_t values_per_mini_block_;
@@ -2268,11 +2268,11 @@ class DeltaLengthByteArrayDecoder : public DecoderImpl,
   void SetData(int num_values, const uint8_t* data, int len) override {
     num_values_ = num_values;
     if (len == 0) return;
-    decoder_ = std::make_shared<::arrow::BitUtil::BitReader>(data, len);
+    decoder_ = std::make_shared<::arrow::bit_util::BitReader>(data, len);
     DecodeLengths();
   }
 
-  void SetDecoder(int num_values, std::shared_ptr<::arrow::BitUtil::BitReader> decoder) {
+  void SetDecoder(int num_values, std::shared_ptr<::arrow::bit_util::BitReader> decoder) {
     num_values_ = num_values;
     decoder_ = decoder;
     DecodeLengths();
@@ -2347,7 +2347,7 @@ class DeltaLengthByteArrayDecoder : public DecoderImpl,
     num_valid_values_ = num_length;
   }
 
-  std::shared_ptr<::arrow::BitUtil::BitReader> decoder_;
+  std::shared_ptr<::arrow::bit_util::BitReader> decoder_;
   DeltaBitPackDecoder<Int32Type> len_decoder_;
   int num_valid_values_;
   uint32_t length_idx_;
@@ -2372,7 +2372,7 @@ class DeltaByteArrayDecoder : public DecoderImpl,
 
   void SetData(int num_values, const uint8_t* data, int len) override {
     num_values_ = num_values;
-    decoder_ = std::make_shared<::arrow::BitUtil::BitReader>(data, len);
+    decoder_ = std::make_shared<::arrow::bit_util::BitReader>(data, len);
     prefix_len_decoder_.SetDecoder(num_values, decoder_);
 
     // get the number of encoded prefix lengths
@@ -2500,7 +2500,7 @@ class DeltaByteArrayDecoder : public DecoderImpl,
     return Status::OK();
   }
 
-  std::shared_ptr<::arrow::BitUtil::BitReader> decoder_;
+  std::shared_ptr<::arrow::bit_util::BitReader> decoder_;
   DeltaBitPackDecoder<Int32Type> prefix_len_decoder_;
   DeltaLengthByteArrayDecoder suffix_decoder_;
   std::string last_value_;
diff --git a/cpp/src/parquet/encoding_test.cc b/cpp/src/parquet/encoding_test.cc
index d271d59ef27..99af5c050d0 100644
--- a/cpp/src/parquet/encoding_test.cc
+++ b/cpp/src/parquet/encoding_test.cc
@@ -45,7 +45,7 @@ using arrow::default_memory_pool;
 using arrow::MemoryPool;
 using arrow::internal::checked_cast;
 
-namespace BitUtil = arrow::BitUtil;
+namespace bit_util = arrow::bit_util;
 
 namespace parquet {
 
@@ -54,7 +54,7 @@ namespace test {
 TEST(VectorBooleanTest, TestEncodeDecode) {
   // PARQUET-454
   int nvalues = 10000;
-  int nbytes = static_cast<int>(BitUtil::BytesForBits(nvalues));
+  int nbytes = static_cast<int>(bit_util::BytesForBits(nvalues));
 
   std::vector<bool> draws;
   ::arrow::random_is_valid(nvalues, 0.5 /* null prob */, &draws, 0 /* seed */);
@@ -78,7 +78,7 @@ TEST(VectorBooleanTest, TestEncodeDecode) {
   ASSERT_EQ(nvalues, values_decoded);
 
   for (int i = 0; i < nvalues; ++i) {
-    ASSERT_EQ(draws[i], ::arrow::BitUtil::GetBit(decode_data, i)) << i;
+    ASSERT_EQ(draws[i], ::arrow::bit_util::GetBit(decode_data, i)) << i;
   }
 }
 
@@ -133,7 +133,7 @@ template <typename T>
 void VerifyResultsSpaced(T* result, T* expected, int num_values,
                          const uint8_t* valid_bits, int64_t valid_bits_offset) {
   for (auto i = 0; i < num_values; ++i) {
-    if (BitUtil::GetBit(valid_bits, valid_bits_offset + i)) {
+    if (bit_util::GetBit(valid_bits, valid_bits_offset + i)) {
       ASSERT_EQ(expected[i], result[i]) << i;
     }
   }
@@ -150,7 +150,7 @@ template <>
 void VerifyResultsSpaced<FLBA>(FLBA* result, FLBA* expected, int num_values,
                                const uint8_t* valid_bits, int64_t valid_bits_offset) {
   for (auto i = 0; i < num_values; ++i) {
-    if (BitUtil::GetBit(valid_bits, valid_bits_offset + i)) {
+    if (bit_util::GetBit(valid_bits, valid_bits_offset + i)) {
       ASSERT_EQ(0, memcmp(expected[i].ptr, result[i].ptr, flba_length)) << i;
     }
   }
@@ -280,7 +280,7 @@ class TestPlainEncoding : public TestEncodingBase<Type> {
     auto decoder = MakeTypedDecoder<Type>(Encoding::PLAIN, descr_.get());
     int null_count = 0;
     for (auto i = 0; i < num_values_; i++) {
-      if (!BitUtil::GetBit(valid_bits, valid_bits_offset + i)) {
+      if (!bit_util::GetBit(valid_bits, valid_bits_offset + i)) {
         null_count++;
       }
     }
@@ -338,7 +338,8 @@ class TestDictionaryEncoding : public TestEncodingBase<Type> {
   static constexpr int TYPE = Type::type_num;
 
   void CheckRoundtrip() {
-    std::vector<uint8_t> valid_bits(::arrow::BitUtil::BytesForBits(num_values_) + 1, 255);
+    std::vector<uint8_t> valid_bits(::arrow::bit_util::BytesForBits(num_values_) + 1,
+                                    255);
 
     auto base_encoder = MakeEncoder(Type::type_num, Encoding::PLAIN, true, descr_.get());
     auto encoder =
@@ -1058,7 +1059,7 @@ class TestByteStreamSplitEncoding : public TestEncodingBase<Type> {
     }
 
     {
-      std::vector<uint8_t> valid_bits(::arrow::BitUtil::BytesForBits(num_values_), 0);
+      std::vector<uint8_t> valid_bits(::arrow::bit_util::BytesForBits(num_values_), 0);
       std::vector<c_type> expected_filtered_output;
       const int every_nth = 5;
       expected_filtered_output.reserve((num_values_ + every_nth - 1) / every_nth);
@@ -1124,7 +1125,7 @@ template <typename c_type>
 static std::vector<c_type> ToLittleEndian(const std::vector<c_type>& input) {
   std::vector<c_type> data(input.size());
   std::transform(input.begin(), input.end(), data.begin(), [](const c_type& value) {
-    return ::arrow::BitUtil::ToLittleEndian(value);
+    return ::arrow::bit_util::ToLittleEndian(value);
   });
   return data;
 }
diff --git a/cpp/src/parquet/level_comparison_inc.h b/cpp/src/parquet/level_comparison_inc.h
index e21c3e5824d..055f81ffae8 100644
--- a/cpp/src/parquet/level_comparison_inc.h
+++ b/cpp/src/parquet/level_comparison_inc.h
@@ -43,7 +43,7 @@ inline uint64_t LevelsToBitmap(const int16_t* levels, int64_t num_levels,
   for (int x = 0; x < num_levels; x++) {
     mask |= static_cast<uint64_t>(predicate(levels[x]) ? 1 : 0) << x;
   }
-  return ::arrow::BitUtil::ToLittleEndian(mask);
+  return ::arrow::bit_util::ToLittleEndian(mask);
 }
 
 inline MinMax FindMinMaxImpl(const int16_t* levels, int64_t num_levels) {
diff --git a/cpp/src/parquet/level_conversion_inc.h b/cpp/src/parquet/level_conversion_inc.h
index 75c7716c483..57955bcfee1 100644
--- a/cpp/src/parquet/level_conversion_inc.h
+++ b/cpp/src/parquet/level_conversion_inc.h
@@ -309,12 +309,12 @@ int64_t DefLevelsBatchToBitmap(const int16_t* def_levels, const int64_t batch_si
     auto present_bitmap = static_cast<extract_bitmap_t>(internal::GreaterThanBitmap(
         def_levels, batch_size, level_info.repeated_ancestor_def_level - 1));
     auto selected_bits = ExtractBits(defined_bitmap, present_bitmap);
-    int64_t selected_count = ::arrow::BitUtil::PopCount(present_bitmap);
+    int64_t selected_count = ::arrow::bit_util::PopCount(present_bitmap);
     if (ARROW_PREDICT_FALSE(selected_count > upper_bound_remaining)) {
       throw ParquetException("Values read exceeded upper bound");
     }
     writer->AppendWord(selected_bits, selected_count);
-    return ::arrow::BitUtil::PopCount(selected_bits);
+    return ::arrow::bit_util::PopCount(selected_bits);
   } else {
     if (ARROW_PREDICT_FALSE(batch_size > upper_bound_remaining)) {
       std::stringstream ss;
@@ -323,7 +323,7 @@ int64_t DefLevelsBatchToBitmap(const int16_t* def_levels, const int64_t batch_si
     }
 
     writer->AppendWord(defined_bitmap, batch_size);
-    return ::arrow::BitUtil::PopCount(defined_bitmap);
+    return ::arrow::bit_util::PopCount(defined_bitmap);
   }
 }
 
diff --git a/cpp/src/parquet/statistics_test.cc b/cpp/src/parquet/statistics_test.cc
index 60419e83b37..af923e5394c 100644
--- a/cpp/src/parquet/statistics_test.cc
+++ b/cpp/src/parquet/statistics_test.cc
@@ -47,7 +47,7 @@ using arrow::default_memory_pool;
 using arrow::MemoryPool;
 using arrow::util::SafeCopy;
 
-namespace BitUtil = arrow::BitUtil;
+namespace bit_util = arrow::bit_util;
 
 namespace parquet {
 
@@ -318,7 +318,7 @@ class TestStatistics : public PrimitiveTypedTest<TestType> {
 
     auto statistics3 = MakeStatistics<TestType>(this->schema_.Column(0));
     std::vector<uint8_t> valid_bits(
-        BitUtil::BytesForBits(static_cast<uint32_t>(this->values_.size())) + 1, 255);
+        bit_util::BytesForBits(static_cast<uint32_t>(this->values_.size())) + 1, 255);
     statistics3->UpdateSpaced(this->values_ptr_, valid_bits.data(), 0,
                               this->values_.size(), this->values_.size(), 0);
     std::string encoded_min_spaced = statistics3->EncodeMin();
diff --git a/cpp/src/plasma/io.cc b/cpp/src/plasma/io.cc
index 002f4e9991f..b353238d879 100644
--- a/cpp/src/plasma/io.cc
+++ b/cpp/src/plasma/io.cc
@@ -64,11 +64,11 @@ Status WriteBytes(int fd, uint8_t* cursor, size_t length) {
 }
 
 Status WriteMessage(int fd, MessageType type, int64_t length, uint8_t* bytes) {
-  int64_t version = arrow::BitUtil::ToLittleEndian(kPlasmaProtocolVersion);
+  int64_t version = arrow::bit_util::ToLittleEndian(kPlasmaProtocolVersion);
   assert(sizeof(MessageType) == sizeof(int64_t));
   type = static_cast<MessageType>(
-      arrow::BitUtil::ToLittleEndian(static_cast<int64_t>(type)));
-  int64_t length_le = arrow::BitUtil::ToLittleEndian(length);
+      arrow::bit_util::ToLittleEndian(static_cast<int64_t>(type)));
+  int64_t length_le = arrow::bit_util::ToLittleEndian(length);
   RETURN_NOT_OK(WriteBytes(fd, reinterpret_cast<uint8_t*>(&version), sizeof(version)));
   RETURN_NOT_OK(WriteBytes(fd, reinterpret_cast<uint8_t*>(&type), sizeof(type)));
   RETURN_NOT_OK(WriteBytes(fd, reinterpret_cast<uint8_t*>(&length_le), sizeof(length)));
@@ -102,19 +102,19 @@ Status ReadMessage(int fd, MessageType* type, std::vector<uint8_t>* buffer) {
   int64_t version;
   RETURN_NOT_OK_ELSE(ReadBytes(fd, reinterpret_cast<uint8_t*>(&version), sizeof(version)),
                      *type = MessageType::PlasmaDisconnectClient);
-  version = arrow::BitUtil::FromLittleEndian(version);
+  version = arrow::bit_util::FromLittleEndian(version);
   ARROW_CHECK(version == kPlasmaProtocolVersion) << "version = " << version;
   RETURN_NOT_OK_ELSE(ReadBytes(fd, reinterpret_cast<uint8_t*>(type), sizeof(*type)),
                      *type = MessageType::PlasmaDisconnectClient);
   assert(sizeof(MessageType) == sizeof(int64_t));
   *type = static_cast<MessageType>(
-      arrow::BitUtil::FromLittleEndian(static_cast<int64_t>(*type)));
+      arrow::bit_util::FromLittleEndian(static_cast<int64_t>(*type)));
   int64_t length_temp;
   RETURN_NOT_OK_ELSE(
       ReadBytes(fd, reinterpret_cast<uint8_t*>(&length_temp), sizeof(length_temp)),
       *type = MessageType::PlasmaDisconnectClient);
   // The length must be read as an int64_t, but it should be used as a size_t.
-  size_t length = static_cast<size_t>(arrow::BitUtil::FromLittleEndian(length_temp));
+  size_t length = static_cast<size_t>(arrow::bit_util::FromLittleEndian(length_temp));
   if (length > buffer->size()) {
     buffer->resize(length);
   }
diff --git a/cpp/thirdparty/versions.txt b/cpp/thirdparty/versions.txt
index 82b290c74be..7156f143e15 100644
--- a/cpp/thirdparty/versions.txt
+++ b/cpp/thirdparty/versions.txt
@@ -43,8 +43,8 @@ ARROW_CARES_BUILD_VERSION=1.17.1
 ARROW_CARES_BUILD_SHA256_CHECKSUM=d73dd0f6de824afd407ce10750ea081af47eba52b8a6cb307d220131ad93fc40
 ARROW_CRC32C_BUILD_VERSION=1.1.2
 ARROW_CRC32C_BUILD_SHA256_CHECKSUM=ac07840513072b7fcebda6e821068aa04889018f24e10e46181068fb214d7e56
-ARROW_GBENCHMARK_BUILD_VERSION=v1.5.2
-ARROW_GBENCHMARK_BUILD_SHA256_CHECKSUM=dccbdab796baa1043f04982147e67bb6e118fe610da2c65f88912d73987e700c
+ARROW_GBENCHMARK_BUILD_VERSION=v1.6.0
+ARROW_GBENCHMARK_BUILD_SHA256_CHECKSUM=1f71c72ce08d2c1310011ea6436b31e39ccab8c2db94186d26657d41747c85d6
 ARROW_GFLAGS_BUILD_VERSION=v2.2.2
 ARROW_GFLAGS_BUILD_SHA256_CHECKSUM=34af2f15cf7367513b352bdcd2493ab14ce43692d2dcd9dfc499492966c64dcf
 ARROW_GLOG_BUILD_VERSION=v0.4.0
@@ -66,6 +66,11 @@ ARROW_MIMALLOC_BUILD_VERSION=v1.7.2
 ARROW_MIMALLOC_BUILD_SHA256_CHECKSUM=b1912e354565a4b698410f7583c0f83934a6dbb3ade54ab7ddcb1569320936bd
 ARROW_NLOHMANN_JSON_BUILD_VERSION=v3.10.2
 ARROW_NLOHMANN_JSON_BUILD_SHA256_CHECKSUM=081ed0f9f89805c2d96335c3acfa993b39a0a5b4b4cef7edb68dd2210a13458c
+ARROW_OPENTELEMETRY_BUILD_VERSION=v1.0.1
+ARROW_OPENTELEMETRY_BUILD_SHA256_CHECKSUM=32f12ff15ec257e3462883f84bc291c2d5dc30055604c12ec4b46a36dfa3f189
+# The commit hash that opentelemetry-cpp pins to in third_party
+ARROW_OPENTELEMETRY_PROTO_BUILD_VERSION=795cc815ce9bb438b46a4a7f6ecb465b52d50935
+ARROW_OPENTELEMETRY_PROTO_BUILD_SHA256_CHECKSUM=e5541011a0bc9e11a1750894280f82c7138e07c3064897fe37a60abcad4f0218
 ARROW_ORC_BUILD_VERSION=1.7.1
 ARROW_ORC_BUILD_SHA256_CHECKSUM=65d71e571238cbcb7c3cbb9a10f7ad988f452d17c58479154be3b9d6ec27d005
 ARROW_PROTOBUF_BUILD_VERSION=v3.17.3
@@ -119,6 +124,8 @@ DEPENDENCIES=(
   "ARROW_LZ4_URL lz4-${ARROW_LZ4_BUILD_VERSION}.tar.gz https://github.com/lz4/lz4/archive/${ARROW_LZ4_BUILD_VERSION}.tar.gz"
   "ARROW_MIMALLOC_URL mimalloc-${ARROW_MIMALLOC_BUILD_VERSION}.tar.gz https://github.com/microsoft/mimalloc/archive/${ARROW_MIMALLOC_BUILD_VERSION}.tar.gz"
   "ARROW_NLOHMANN_JSON_URL nlohmann-json-${ARROW_NLOHMANN_JSON_BUILD_VERSION}.tar.gz https://github.com/nlohmann/json/archive/refs/tags/${ARROW_NLOHMANN_JSON_BUILD_VERSION}.tar.gz"
+  "ARROW_OPENTELEMETRY_URL opentelemetry-cpp-${ARROW_OPENTELEMETRY_BUILD_VERSION}.tar.gz https://github.com/open-telemetry/opentelemetry-cpp/archive/refs/tags/${ARROW_OPENTELEMETRY_BUILD_VERSION}.tar.gz"
+  "ARROW_OPENTELEMETRY_PROTO_URL opentelemetry-proto-${ARROW_OPENTELEMETRY_PROTO_BUILD_VERSION}.tar.gz https://github.com/open-telemetry/opentelemetry-proto/archive/${ARROW_OPENTELEMETRY_PROTO_BUILD_VERSION}.tar.gz"
   "ARROW_ORC_URL orc-${ARROW_ORC_BUILD_VERSION}.tar.gz https://archive.apache.org/dist/orc/orc-${ARROW_ORC_BUILD_VERSION}/orc-${ARROW_ORC_BUILD_VERSION}.tar.gz"
   "ARROW_PROTOBUF_URL protobuf-${ARROW_PROTOBUF_BUILD_VERSION}.tar.gz https://github.com/google/protobuf/releases/download/${ARROW_PROTOBUF_BUILD_VERSION}/protobuf-all-${ARROW_PROTOBUF_BUILD_VERSION:1}.tar.gz"
   "ARROW_RAPIDJSON_URL rapidjson-${ARROW_RAPIDJSON_BUILD_VERSION}.tar.gz https://github.com/miloyip/rapidjson/archive/${ARROW_RAPIDJSON_BUILD_VERSION}.tar.gz"
diff --git a/cpp/vcpkg.json b/cpp/vcpkg.json
index f74b4d3e37b..a6e9c68b57d 100644
--- a/cpp/vcpkg.json
+++ b/cpp/vcpkg.json
@@ -17,6 +17,7 @@
     "benchmark",
     "boost-filesystem",
     "boost-multiprecision",
+    "boost-process",
     "boost-system",
     "brotli",
     "bzip2",
@@ -25,6 +26,14 @@
     "flatbuffers",
     "gflags",
     "glog",
+    {
+      "name":"google-cloud-cpp",
+      "version>=": "1.32.1",
+      "default-features": false,
+      "features": [
+        "storage"
+      ]
+    },
     "grpc",
     "gtest",
     "lz4",
diff --git a/dev/archery/archery/bot.py b/dev/archery/archery/bot.py
index e8fbbdd04cf..14b3e47954e 100644
--- a/dev/archery/archery/bot.py
+++ b/dev/archery/archery/bot.py
@@ -93,9 +93,6 @@ def __init__(self, name, handler, token=None):
         self.github = github.Github(token)
 
     def parse_command(self, payload):
-        # only allow users of apache org to submit commands, for more see
-        # https://developer.github.com/v4/enum/commentauthorassociation/
-        allowed_roles = {'OWNER', 'MEMBER', 'CONTRIBUTOR'}
         mention = '@{}'.format(self.name)
         comment = payload['comment']
 
@@ -103,10 +100,6 @@ def parse_command(self, payload):
             raise EventError("Don't respond to itself")
         elif payload['action'] not in {'created', 'edited'}:
             raise EventError("Don't respond to comment deletion")
-        elif comment['author_association'] not in allowed_roles:
-            raise EventError(
-                "Don't respond to comments from non-authorized users"
-            )
         elif not comment['body'].lstrip().startswith(mention):
             raise EventError("The bot is not mentioned")
 
@@ -146,13 +139,28 @@ def handle_issue_comment(self, command, payload):
 
         comment = pull.get_issue_comment(payload['comment']['id'])
         try:
+            # Only allow users of apache org to submit commands, for more see
+            # https://developer.github.com/v4/enum/commentauthorassociation/
+            # Checking  privileges here enables the bot to respond
+            # without relying on the handler.
+            allowed_roles = {'OWNER', 'MEMBER', 'CONTRIBUTOR'}
+            if payload['comment']['author_association'] not in allowed_roles:
+                raise EventError(
+                    "Only contributors can submit requests to this bot. "
+                    "Please ask someone from the community for help with "
+                    "getting the first commit in."
+                )
             self.handler(command, issue=issue, pull_request=pull,
                          comment=comment)
-        except CommandError as e:
-            logger.error(e)
-            pull.create_issue_comment("```\n{}\n```".format(e.message))
         except Exception as e:
             logger.exception(e)
+            url = "{server}/{repo}/actions/runs/{run_id}".format(
+                server=os.environ["GITHUB_SERVER_URL"],
+                repo=os.environ["GITHUB_REPOSITORY"],
+                run_id=os.environ["GITHUB_RUN_ID"],
+            )
+            pull.create_issue_comment(
+                f"```\n{e}\nThe Archery job run can be found at: {url}```")
             comment.create_reaction('-1')
         else:
             comment.create_reaction('+1')
diff --git a/dev/archery/archery/docker.py b/dev/archery/archery/docker.py
deleted file mode 100644
index 17d4c713afc..00000000000
--- a/dev/archery/archery/docker.py
+++ /dev/null
@@ -1,402 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-import os
-import re
-import subprocess
-from io import StringIO
-
-from dotenv import dotenv_values
-from ruamel.yaml import YAML
-
-from .utils.command import Command, default_bin
-from .compat import _ensure_path
-
-
-def flatten(node, parents=None):
-    parents = list(parents or [])
-    if isinstance(node, str):
-        yield (node, parents)
-    elif isinstance(node, list):
-        for value in node:
-            yield from flatten(value, parents=parents)
-    elif isinstance(node, dict):
-        for key, value in node.items():
-            yield (key, parents)
-            yield from flatten(value, parents=parents + [key])
-    else:
-        raise TypeError(node)
-
-
-def _sanitize_command(cmd):
-    if isinstance(cmd, list):
-        cmd = " ".join(cmd)
-    return re.sub(r"\s+", " ", cmd)
-
-
-class UndefinedImage(Exception):
-    pass
-
-
-class ComposeConfig:
-
-    def __init__(self, config_path, dotenv_path, compose_bin, params=None):
-        config_path = _ensure_path(config_path)
-        if dotenv_path:
-            dotenv_path = _ensure_path(dotenv_path)
-        else:
-            dotenv_path = config_path.parent / '.env'
-        self._read_env(dotenv_path, params)
-        self._read_config(config_path, compose_bin)
-
-    def _read_env(self, dotenv_path, params):
-        """
-        Read .env and merge it with explicitly passed parameters.
-        """
-        self.dotenv = dotenv_values(str(dotenv_path))
-        if params is None:
-            self.params = {}
-        else:
-            self.params = {k: v for k, v in params.items() if k in self.dotenv}
-
-        # forward the process' environment variables
-        self.env = os.environ.copy()
-        # set the defaults from the dotenv files
-        self.env.update(self.dotenv)
-        # override the defaults passed as parameters
-        self.env.update(self.params)
-
-        # translate docker's architecture notation to a more widely used one
-        arch = self.env.get('ARCH', 'amd64')
-        arch_aliases = {
-            'amd64': 'x86_64',
-            'arm64v8': 'aarch64',
-            's390x': 's390x'
-        }
-        arch_short_aliases = {
-            'amd64': 'x64',
-            'arm64v8': 'arm64',
-            's390x': 's390x'
-        }
-        self.env['ARCH_ALIAS'] = arch_aliases.get(arch, arch)
-        self.env['ARCH_SHORT_ALIAS'] = arch_short_aliases.get(arch, arch)
-
-    def _read_config(self, config_path, compose_bin):
-        """
-        Validate and read the docker-compose.yml
-        """
-        yaml = YAML()
-        with config_path.open() as fp:
-            config = yaml.load(fp)
-
-        services = config['services'].keys()
-        self.hierarchy = dict(flatten(config.get('x-hierarchy', {})))
-        self.with_gpus = config.get('x-with-gpus', [])
-        nodes = self.hierarchy.keys()
-        errors = []
-
-        for name in self.with_gpus:
-            if name not in services:
-                errors.append(
-                    'Service `{}` defined in `x-with-gpus` bot not in '
-                    '`services`'.format(name)
-                )
-        for name in nodes - services:
-            errors.append(
-                'Service `{}` is defined in `x-hierarchy` bot not in '
-                '`services`'.format(name)
-            )
-        for name in services - nodes:
-            errors.append(
-                'Service `{}` is defined in `services` but not in '
-                '`x-hierarchy`'.format(name)
-            )
-
-        # trigger docker-compose's own validation
-        compose = Command('docker-compose')
-        args = ['--file', str(config_path), 'config']
-        result = compose.run(*args, env=self.env, check=False,
-                             stderr=subprocess.PIPE, stdout=subprocess.PIPE)
-
-        if result.returncode != 0:
-            # strip the intro line of docker-compose errors
-            errors += result.stderr.decode().splitlines()
-
-        if errors:
-            msg = '\n'.join([' - {}'.format(msg) for msg in errors])
-            raise ValueError(
-                'Found errors with docker-compose:\n{}'.format(msg)
-            )
-
-        rendered_config = StringIO(result.stdout.decode())
-        self.path = config_path
-        self.config = yaml.load(rendered_config)
-
-    def get(self, service_name):
-        try:
-            service = self.config['services'][service_name]
-        except KeyError:
-            raise UndefinedImage(service_name)
-        service['name'] = service_name
-        service['need_gpu'] = service_name in self.with_gpus
-        service['ancestors'] = self.hierarchy[service_name]
-        return service
-
-    def __getitem__(self, service_name):
-        return self.get(service_name)
-
-
-class Docker(Command):
-
-    def __init__(self, docker_bin=None):
-        self.bin = default_bin(docker_bin, "docker")
-
-
-class DockerCompose(Command):
-
-    def __init__(self, config_path, dotenv_path=None, compose_bin=None,
-                 params=None):
-        compose_bin = default_bin(compose_bin, 'docker-compose')
-        self.config = ComposeConfig(config_path, dotenv_path, compose_bin,
-                                    params)
-        self.bin = compose_bin
-        self.pull_memory = set()
-
-    def clear_pull_memory(self):
-        self.pull_memory = set()
-
-    def _execute_compose(self, *args, **kwargs):
-        # execute as a docker compose command
-        try:
-            result = super().run('--file', str(self.config.path), *args,
-                                 env=self.config.env, **kwargs)
-            result.check_returncode()
-        except subprocess.CalledProcessError as e:
-            def formatdict(d, template):
-                return '\n'.join(
-                    template.format(k, v) for k, v in sorted(d.items())
-                )
-            msg = (
-                "`{cmd}` exited with a non-zero exit code {code}, see the "
-                "process log above.\n\nThe docker-compose command was "
-                "invoked with the following parameters:\n\nDefaults defined "
-                "in .env:\n{dotenv}\n\nArchery was called with:\n{params}"
-            )
-            raise RuntimeError(
-                msg.format(
-                    cmd=' '.join(e.cmd),
-                    code=e.returncode,
-                    dotenv=formatdict(self.config.dotenv, template='  {}: {}'),
-                    params=formatdict(
-                        self.config.params, template='  export {}={}'
-                    )
-                )
-            )
-
-    def _execute_docker(self, *args, **kwargs):
-        # execute as a plain docker cli command
-        try:
-            result = Docker().run(*args, **kwargs)
-            result.check_returncode()
-        except subprocess.CalledProcessError as e:
-            raise RuntimeError(
-                "{} exited with non-zero exit code {}".format(
-                    ' '.join(e.cmd), e.returncode
-                )
-            )
-
-    def pull(self, service_name, pull_leaf=True, using_docker=False):
-        def _pull(service):
-            args = ['pull']
-            if service['image'] in self.pull_memory:
-                return
-
-            if using_docker:
-                try:
-                    self._execute_docker(*args, service['image'])
-                except Exception as e:
-                    # better --ignore-pull-failures handling
-                    print(e)
-            else:
-                args.append('--ignore-pull-failures')
-                self._execute_compose(*args, service['name'])
-
-            self.pull_memory.add(service['image'])
-
-        service = self.config.get(service_name)
-        for ancestor in service['ancestors']:
-            _pull(self.config.get(ancestor))
-        if pull_leaf:
-            _pull(service)
-
-    def build(self, service_name, use_cache=True, use_leaf_cache=True,
-              using_docker=False, using_buildx=False):
-        def _build(service, use_cache):
-            if 'build' not in service:
-                # nothing to do
-                return
-
-            args = []
-            cache_from = list(service.get('build', {}).get('cache_from', []))
-            if use_cache:
-                for image in cache_from:
-                    if image not in self.pull_memory:
-                        try:
-                            self._execute_docker('pull', image)
-                        except Exception as e:
-                            print(e)
-                        finally:
-                            self.pull_memory.add(image)
-            else:
-                args.append('--no-cache')
-
-            # turn on inline build cache, this is a docker buildx feature
-            # used to bundle the image build cache to the pushed image manifest
-            # so the build cache can be reused across hosts, documented at
-            # https://github.com/docker/buildx#--cache-tonametypetypekeyvalue
-            if self.config.env.get('BUILDKIT_INLINE_CACHE') == '1':
-                args.extend(['--build-arg', 'BUILDKIT_INLINE_CACHE=1'])
-
-            if using_buildx:
-                for k, v in service['build'].get('args', {}).items():
-                    args.extend(['--build-arg', '{}={}'.format(k, v)])
-
-                if use_cache:
-                    cache_ref = '{}-cache'.format(service['image'])
-                    cache_from = 'type=registry,ref={}'.format(cache_ref)
-                    cache_to = (
-                        'type=registry,ref={},mode=max'.format(cache_ref)
-                    )
-                    args.extend([
-                        '--cache-from', cache_from,
-                        '--cache-to', cache_to,
-                    ])
-
-                args.extend([
-                    '--output', 'type=docker',
-                    '-f', service['build']['dockerfile'],
-                    '-t', service['image'],
-                    service['build'].get('context', '.')
-                ])
-                self._execute_docker("buildx", "build", *args)
-            elif using_docker:
-                # better for caching
-                for k, v in service['build'].get('args', {}).items():
-                    args.extend(['--build-arg', '{}={}'.format(k, v)])
-                for img in cache_from:
-                    args.append('--cache-from="{}"'.format(img))
-                args.extend([
-                    '-f', service['build']['dockerfile'],
-                    '-t', service['image'],
-                    service['build'].get('context', '.')
-                ])
-                self._execute_docker("build", *args)
-            else:
-                self._execute_compose("build", *args, service['name'])
-
-        service = self.config.get(service_name)
-        # build ancestor services
-        for ancestor in service['ancestors']:
-            _build(self.config.get(ancestor), use_cache=use_cache)
-        # build the leaf/target service
-        _build(service, use_cache=use_cache and use_leaf_cache)
-
-    def run(self, service_name, command=None, *, env=None, volumes=None,
-            user=None, using_docker=False):
-        service = self.config.get(service_name)
-
-        args = []
-        if user is not None:
-            args.extend(['-u', user])
-
-        if env is not None:
-            for k, v in env.items():
-                args.extend(['-e', '{}={}'.format(k, v)])
-
-        if volumes is not None:
-            for volume in volumes:
-                args.extend(['--volume', volume])
-
-        if using_docker or service['need_gpu']:
-            # use gpus, requires docker>=19.03
-            if service['need_gpu']:
-                args.extend(['--gpus', 'all'])
-
-            if service.get('shm_size'):
-                args.extend(['--shm-size', service['shm_size']])
-
-            # append env variables from the compose conf
-            for k, v in service.get('environment', {}).items():
-                args.extend(['-e', '{}={}'.format(k, v)])
-
-            # append volumes from the compose conf
-            for v in service.get('volumes', []):
-                if not isinstance(v, str):
-                    # if not the compact string volume definition
-                    v = "{}:{}".format(v['source'], v['target'])
-                args.extend(['-v', v])
-
-            # infer whether an interactive shell is desired or not
-            if command in ['cmd.exe', 'bash', 'sh', 'powershell']:
-                args.append('-it')
-
-            # get the actual docker image name instead of the compose service
-            # name which we refer as image in general
-            args.append(service['image'])
-
-            # add command from compose if it wasn't overridden
-            if command is not None:
-                args.append(command)
-            else:
-                # replace whitespaces from the preformatted compose command
-                cmd = _sanitize_command(service.get('command', ''))
-                if cmd:
-                    args.append(cmd)
-
-            # execute as a plain docker cli command
-            self._execute_docker('run', '--rm', *args)
-        else:
-            # execute as a docker-compose command
-            args.append(service_name)
-            if command is not None:
-                args.append(command)
-            self._execute_compose('run', '--rm', *args)
-
-    def push(self, service_name, user=None, password=None, using_docker=False):
-        def _push(service):
-            if using_docker:
-                return self._execute_docker('push', service['image'])
-            else:
-                return self._execute_compose('push', service['name'])
-
-        if user is not None:
-            try:
-                # TODO(kszucs): have an option for a prompt
-                self._execute_docker('login', '-u', user, '-p', password)
-            except subprocess.CalledProcessError:
-                # hide credentials
-                msg = ('Failed to push `{}`, check the passed credentials'
-                       .format(service_name))
-                raise RuntimeError(msg) from None
-
-        service = self.config.get(service_name)
-        for ancestor in service['ancestors']:
-            _push(self.config.get(ancestor))
-        _push(service)
-
-    def images(self):
-        return sorted(self.config.hierarchy.keys())
diff --git a/dev/archery/archery/docker/core.py b/dev/archery/archery/docker/core.py
index aaf16bdfa6e..dfdf3f4778a 100644
--- a/dev/archery/archery/docker/core.py
+++ b/dev/archery/archery/docker/core.py
@@ -48,6 +48,15 @@ def _sanitize_command(cmd):
     return re.sub(r"\s+", " ", cmd)
 
 
+_arch_short_mapping = {
+    'arm64v8': 'arm64',
+}
+_arch_alias_mapping = {
+    'amd64': 'x86_64',
+    'arm64v8': 'aarch64',
+}
+
+
 class UndefinedImage(Exception):
     pass
 
@@ -82,18 +91,8 @@ def _read_env(self, dotenv_path, params):
 
         # translate docker's architecture notation to a more widely used one
         arch = self.env.get('ARCH', 'amd64')
-        arch_aliases = {
-            'amd64': 'x86_64',
-            'arm64v8': 'aarch64',
-            's390x': 's390x'
-        }
-        arch_short_aliases = {
-            'amd64': 'x64',
-            'arm64v8': 'arm64',
-            's390x': 's390x'
-        }
-        self.env['ARCH_ALIAS'] = arch_aliases.get(arch, arch)
-        self.env['ARCH_SHORT_ALIAS'] = arch_short_aliases.get(arch, arch)
+        self.env['ARCH_ALIAS'] = _arch_alias_mapping.get(arch, arch)
+        self.env['ARCH_SHORT'] = _arch_short_mapping.get(arch, arch)
 
     def _read_config(self, config_path, compose_bin):
         """
diff --git a/dev/archery/archery/tests/test_bot.py b/dev/archery/archery/tests/test_bot.py
index e84fb7e273a..f2c77837664 100644
--- a/dev/archery/archery/tests/test_bot.py
+++ b/dev/archery/archery/tests/test_bot.py
@@ -16,6 +16,8 @@
 # under the License.
 
 import json
+import os
+from unittest import mock
 from unittest.mock import Mock
 
 import click
@@ -31,6 +33,16 @@ def responses():
         yield mock
 
 
+@pytest.fixture(autouse=True)
+def set_env_vars():
+    with mock.patch.dict(os.environ, {
+        "GITHUB_SERVER_URL": "https://github.com",
+        "GITHUB_REPOSITORY": "apache/arrow",
+        "GITHUB_RUN_ID": "1463784188"
+    }):
+        yield
+
+
 def github_url(path):
     return 'https://api.github.com:443/{}'.format(path.strip('/'))
 
@@ -74,8 +86,6 @@ def test_click_based_commands():
     'event-issue-comment-not-mentioning-ursabot.json',
     # don't respond to itself, it prevents recursive comment storms!
     'event-issue-comment-by-ursabot.json',
-    # non-authorized user sent the comment, do not respond
-    'event-issue-comment-by-non-authorized-user.json',
 ])
 def test_noop_events(load_fixture, fixture_name):
     payload = load_fixture(fixture_name)
@@ -87,6 +97,58 @@ def test_noop_events(load_fixture, fixture_name):
     handler.assert_not_called()
 
 
+def test_unathorized_user_comment(load_fixture, responses):
+    responses.add(
+        responses.GET,
+        github_url('/repositories/169101701/issues/26'),
+        json=load_fixture('issue-26.json'),
+        status=200
+    )
+    responses.add(
+        responses.GET,
+        github_url('/repos/ursa-labs/ursabot/pulls/26'),
+        json=load_fixture('pull-request-26.json'),
+        status=200
+    )
+    responses.add(
+        responses.GET,
+        github_url('/repos/ursa-labs/ursabot/issues/comments/480243815'),
+        json=load_fixture('pull-request-26.json'),
+        status=200
+    )
+    responses.add(
+        responses.POST,
+        github_url('/repos/ursa-labs/ursabot/issues/26/comments'),
+        json={}
+    )
+    responses.add(
+        responses.POST,
+        github_url(
+            '/repos/ursa-labs/ursabot/pulls/26/reactions'),
+        json=()
+    )
+
+    def handler(command, **kwargs):
+        pass
+
+    payload = load_fixture('event-issue-comment-by-non-authorized-user.json')
+    payload["comment"]["body"] = '@ursabot crossbow submit -g nightly'
+    bot = CommentBot(name='ursabot', token='', handler=handler)
+    bot.handle('issue_comment', payload)
+
+    print([c.request.body for c in responses.calls])
+    post = responses.calls[-2]
+    reaction = responses.calls[-1]
+    comment = ("```\nOnly contributors can submit requests to this bot. "
+               "Please ask someone from the community for help with getting "
+               "the first commit in.\n"
+               "The Archery job run can be found at: "
+               "https://github.com/apache/arrow/actions/runs/1463784188```")
+    assert json.loads(post.request.body) == {
+        "body": f'{comment}'}
+    assert json.loads(reaction.request.body) == {'content': '-1'}
+
+
 def test_issue_comment_without_pull_request(load_fixture, responses):
     responses.add(
         responses.GET,
@@ -142,6 +204,12 @@ def test_respond_with_usage(load_fixture, responses):
         github_url('/repos/ursa-labs/ursabot/issues/26/comments'),
         json={}
     )
+    responses.add(
+        responses.POST,
+        github_url(
+            '/repos/ursa-labs/ursabot/issues/comments/479081273/reactions'),
+        json=()
+    )
 
     def handler(command, **kwargs):
         raise CommandError('test-usage')
@@ -151,13 +219,17 @@ def handler(command, **kwargs):
     bot.handle('issue_comment', payload)
 
     post = responses.calls[3]
-    assert json.loads(post.request.body) == {'body': '```\ntest-usage\n```'}
+    assert json.loads(post.request.body) == \
+        {'body':
+         ("```\ntest-usage\n"
+          "The Archery job run can be found at: "
+          "https://github.com/apache/arrow/actions/runs/1463784188```")
+         }
 
 
 @pytest.mark.parametrize(('command', 'reaction'), [
     ('@ursabot build', '+1'),
     ('@ursabot build\nwith a comment', '+1'),
-    ('@ursabot listen', '-1'),
 ])
 def test_issue_comment_with_commands(load_fixture, responses, command,
                                      reaction):
@@ -202,6 +274,58 @@ def handler(command, **kwargs):
     assert json.loads(post.request.body) == {'content': reaction}
 
 
+@pytest.mark.parametrize(('command', 'reaction'), [
+    ('@ursabot listen', '-1'),
+])
+def test_issue_comment_invalid_commands(load_fixture, responses, command,
+                                        reaction):
+    responses.add(
+        responses.GET,
+        github_url('/repositories/169101701/issues/26'),
+        json=load_fixture('issue-26.json'),
+        status=200
+    )
+    responses.add(
+        responses.GET,
+        github_url('/repos/ursa-labs/ursabot/pulls/26'),
+        json=load_fixture('pull-request-26.json'),
+        status=200
+    )
+    responses.add(
+        responses.GET,
+        github_url('/repos/ursa-labs/ursabot/issues/comments/480248726'),
+        json=load_fixture('issue-comment-480248726.json')
+    )
+    responses.add(
+        responses.POST,
+        github_url(
+            '/repos/ursa-labs/ursabot/issues/comments/480248726/reactions'
+        ),
+        json={}
+    )
+    responses.add(
+        responses.POST,
+        github_url('/repos/ursa-labs/ursabot/issues/26/comments'),
+        json={}
+    )
+
+    def handler(command, **kwargs):
+        if command == 'build':
+            return True
+        else:
+            raise ValueError('Only `build` command is supported.')
+
+    payload = load_fixture('event-issue-comment-build-command.json')
+    payload["comment"]["body"] = command
+
+    bot = CommentBot(name='ursabot', token='', handler=handler)
+    bot.handle('issue_comment', payload)
+
+    # Setting reaction is always the last call
+    post = responses.calls[-1]
+    assert json.loads(post.request.body) == {'content': reaction}
+
+
 def test_issue_comment_with_commands_bot_not_first(load_fixture, responses):
     # when the @-mention is not first, this is a no-op
     handler = Mock()
diff --git a/dev/release/05-binary-upload.sh b/dev/release/05-binary-upload.sh
index 4dd4a5040ba..5a30fc8bdf8 100755
--- a/dev/release/05-binary-upload.sh
+++ b/dev/release/05-binary-upload.sh
@@ -68,7 +68,6 @@ fi
 : ${UPLOAD_AMAZON_LINUX:=${UPLOAD_DEFAULT}}
 : ${UPLOAD_CENTOS:=${UPLOAD_DEFAULT}}
 : ${UPLOAD_DEBIAN:=${UPLOAD_DEFAULT}}
-: ${UPLOAD_JAVA:=${UPLOAD_DEFAULT}}
 : ${UPLOAD_NUGET:=${UPLOAD_DEFAULT}}
 : ${UPLOAD_PYTHON:=${UPLOAD_DEFAULT}}
 : ${UPLOAD_UBUNTU:=${UPLOAD_DEFAULT}}
@@ -92,9 +91,6 @@ if [ ${UPLOAD_DEBIAN} -gt 0 ]; then
   rake_tasks+=(apt:rc)
   apt_targets+=(debian)
 fi
-if [ ${UPLOAD_JAVA} -gt 0 ]; then
-  rake_tasks+=(java:rc)
-fi
 if [ ${UPLOAD_NUGET} -gt 0 ]; then
   rake_tasks+=(nuget:rc)
 fi
diff --git a/dev/release/06-java-upload.sh b/dev/release/06-java-upload.sh
new file mode 100755
index 00000000000..5b2755850c0
--- /dev/null
+++ b/dev/release/06-java-upload.sh
@@ -0,0 +1,140 @@
+#!/usr/bin/env bash
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+set -e
+set -u
+set -o pipefail
+
+SOURCE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+if [ "$#" -ne 2 ]; then
+  echo "Usage: $0 <version> <rc-num>"
+  exit
+fi
+
+version=$1
+rc=$2
+
+pushd "${SOURCE_DIR}"
+if [ ! -f .env ]; then
+  echo "You must create $(pwd)/.env"
+  echo "You can use $(pwd)/.env.example as template"
+  exit 1
+fi
+. .env
+popd
+
+version_with_rc="${version}-rc${rc}"
+crossbow_job_prefix="release-${version_with_rc}"
+crossbow_package_dir="${SOURCE_DIR}/../../packages"
+
+: ${CROSSBOW_JOB_NUMBER:="0"}
+: ${CROSSBOW_JOB_ID:="${crossbow_job_prefix}-${CROSSBOW_JOB_NUMBER}"}
+artifact_dir="${crossbow_package_dir}/${CROSSBOW_JOB_ID}"
+
+if [ ! -e "${artifact_dir}" ]; then
+  echo "${artifact_dir} does not exist"
+  exit 1
+fi
+
+if [ ! -d "${artifact_dir}" ]; then
+  echo "${artifact_dir} is not a directory"
+  exit 1
+fi
+
+cd "${artifact_dir}/java-jars"
+
+files=
+types=
+classifiers=
+
+sign() {
+  local path="$1"
+  local classifier="$2"
+  local type=$(echo "${path}" | grep -o "[^.]*$")
+
+  local asc_path="${path}.asc"
+  rm -f "${asc_path}"
+  gpg \
+    --detach-sig \
+    --local-user "${GPG_KEY_ID}" \
+    --output "${asc_path}" \
+    "${path}"
+  if [ -n "${files}" ]; then
+    files="${files},"
+    types="${types},"
+    classifiers="${classifiers},"
+  fi
+  files="${files}${asc_path}"
+  types="${types}${type}.asc"
+  classifiers="${classifiers}${classifier}"
+
+  # .md5 and .sha1 are generated automatically on repository side.
+  # local sha512_path="${path}.sha512"
+  # shasum --algorithm 512 "${path}" > "${sha512_path}"
+  # files="${files},${sha512_path}"
+  # types="${types},${type}.sha512"
+  # classifiers="${classifiers},${classifier}"
+}
+
+for pom in *.pom; do
+  base=$(basename ${pom} .pom)
+  args=()
+  args+=(deploy:deploy-file)
+  args+=(-Durl=https://repository.apache.org/service/local/staging/deploy/maven2)
+  args+=(-DrepositoryId=apache.releases.https)
+  pom="${PWD}/${pom}"
+  args+=(-DpomFile="${pom}")
+  if [ -f "${base}.jar" ]; then
+    jar="${PWD}/${base}.jar"
+    args+=(-Dfile="${jar}")
+    sign "${jar}" ""
+  else
+    args+=(-Dfile="${pom}")
+  fi
+  sign "${pom}" ""
+  if [ "$(echo ${base}-*)" != "${base}-*" ]; then
+    for other_file in ${base}-*; do
+      file="${PWD}/${other_file}"
+      type=$(echo "${other_file}" | grep -o "[^.]*$")
+      case "${type}" in
+        asc|sha256|sha512)
+          continue
+          ;;
+      esac
+      classifier=$(basename "${other_file}" ".${type}" | sed -e "s/${base}-//g")
+      files="${files},${file}"
+      types="${types},${type}"
+      classifiers="${classifiers},${classifier}"
+      sign "${file}" "${classifier}"
+    done
+  fi
+  args+=(-Dfiles="${files}")
+  args+=(-Dtypes="${types}")
+  args+=(-Dclassifiers="${classifiers}")
+  pushd "${SOURCE_DIR}"
+  mvn deploy:deploy-file "${args[@]}"
+  popd
+done
+
+echo "Success!"
+echo "Press the 'Close' button manually by Web interface:"
+echo "    https://repository.apache.org/#stagingRepositories"
+echo "It publishes the artifacts to the staging repository:"
+echo "    https://repository.apache.org/content/repositories/staging/org/apache/arrow/"
diff --git a/dev/release/binary-task.rb b/dev/release/binary-task.rb
index 10211d05afd..081fbee0c91 100644
--- a/dev/release/binary-task.rb
+++ b/dev/release/binary-task.rb
@@ -739,7 +739,6 @@ def upload
   def define
     define_apt_tasks
     define_yum_tasks
-    define_java_tasks
     define_nuget_tasks
     define_python_tasks
     define_summary_tasks
@@ -1857,14 +1856,6 @@ def define_generic_data_tasks(label,
     define_generic_data_release_tasks(label, id, release_dir)
   end
 
-  def define_java_tasks
-    define_generic_data_tasks("Java",
-                              :java,
-                              "#{rc_dir}/java/#{full_version}",
-                              "#{release_dir}/java/#{full_version}",
-                              "java-jars/**/*")
-  end
-
   def define_nuget_tasks
     define_generic_data_tasks("NuGet",
                               :nuget,
@@ -1893,7 +1884,6 @@ def define_summary_tasks
   https://apache.jfrog.io/artifactory/arrow/amazon-linux#{suffix}-rc/
   https://apache.jfrog.io/artifactory/arrow/centos#{suffix}-rc/
   https://apache.jfrog.io/artifactory/arrow/debian#{suffix}-rc/
-  https://apache.jfrog.io/artifactory/arrow/java#{suffix}-rc/#{version}
   https://apache.jfrog.io/artifactory/arrow/nuget#{suffix}-rc/#{full_version}
   https://apache.jfrog.io/artifactory/arrow/python#{suffix}-rc/#{full_version}
   https://apache.jfrog.io/artifactory/arrow/ubuntu#{suffix}-rc/
@@ -1910,7 +1900,6 @@ def define_summary_tasks
   https://apache.jfrog.io/artifactory/arrow/amazon-linux#{suffix}/
   https://apache.jfrog.io/artifactory/arrow/centos#{suffix}/
   https://apache.jfrog.io/artifactory/arrow/debian#{suffix}/
-  https://apache.jfrog.io/artifactory/arrow/java#{suffix}/#{version}
   https://apache.jfrog.io/artifactory/arrow/nuget#{suffix}/#{version}
   https://apache.jfrog.io/artifactory/arrow/python#{suffix}/#{version}
   https://apache.jfrog.io/artifactory/arrow/ubuntu#{suffix}/
diff --git a/dev/release/download_rc_binaries.py b/dev/release/download_rc_binaries.py
index 1384d785c96..ebd66a274d8 100755
--- a/dev/release/download_rc_binaries.py
+++ b/dev/release/download_rc_binaries.py
@@ -25,27 +25,31 @@
 import urllib.request
 
 
-ARTIFACTORY_ROOT = "https://apache.jfrog.io/artifactory/arrow"
 DEFAULT_PARALLEL_DOWNLOADS = 8
 
 
-class Artifactory:
+class Downloader:
 
-    def get_file_list(self, prefix):
+    def get_file_list(self, prefix, filter=None):
         def traverse(directory, files, directories):
-            url = f'{ARTIFACTORY_ROOT}/{directory}'
+            url = f'{self.URL_ROOT}/{directory}'
             response = urllib.request.urlopen(url).read().decode()
             paths = re.findall('<a href="(.+?)"', response)
             for path in paths:
+                path = re.sub(f'^{re.escape(url)}',
+                              '',
+                              path)
                 if path == '../':
                     continue
                 resolved_path = f'{directory}{path}'
+                if filter and not filter(path):
+                    continue
                 if path.endswith('/'):
                     directories.append(resolved_path)
                 else:
                     files.append(resolved_path)
         files = []
-        if not prefix.endswith('/'):
+        if prefix != '' and not prefix.endswith('/'):
             prefix += '/'
         directories = [prefix]
         while len(directories) > 0:
@@ -98,7 +102,7 @@ def _download_file(self, dest, path):
 
         print("Downloading {} to {}".format(path, dest_path))
 
-        url = f'{ARTIFACTORY_ROOT}/{path}'
+        url = f'{self.URL_ROOT}/{path}'
 
         cmd = [
             'curl', '--fail', '--location', '--retry', '5',
@@ -112,6 +116,15 @@ def _download_file(self, dest, path):
                             .format(path, stdout, stderr))
 
 
+class Artifactory(Downloader):
+    URL_ROOT = "https://apache.jfrog.io/artifactory/arrow"
+
+
+class Maven(Downloader):
+    URL_ROOT = "https://repository.apache.org" + \
+        "/content/repositories/staging/org/apache/arrow"
+
+
 def parallel_map_terminate_early(f, iterable, num_parallel):
     tasks = []
     with cf.ProcessPoolExecutor(num_parallel) as pool:
@@ -133,7 +146,7 @@ def parallel_map_terminate_early(f, iterable, num_parallel):
     'debian',
     'ubuntu',
 ]
-ARROW_STANDALONE_PACKAGE_TYPES = ['java', 'nuget', 'python']
+ARROW_STANDALONE_PACKAGE_TYPES = ['nuget', 'python']
 ARROW_PACKAGE_TYPES = \
     ARROW_REPOSITORY_PACKAGE_TYPES + \
     ARROW_STANDALONE_PACKAGE_TYPES
@@ -141,30 +154,33 @@ def parallel_map_terminate_early(f, iterable, num_parallel):
 
 def download_rc_binaries(version, rc_number, re_match=None, dest=None,
                          num_parallel=None, target_package_type=None):
-    artifactory = Artifactory()
-
     version_string = '{}-rc{}'.format(version, rc_number)
+    version_pattern = re.compile(r'\d+\.\d+\.\d+')
     if target_package_type:
         package_types = [target_package_type]
     else:
         package_types = ARROW_PACKAGE_TYPES
     for package_type in package_types:
-        if package_type in ARROW_REPOSITORY_PACKAGE_TYPES:
+        def is_target(path):
+            match = version_pattern.search(path)
+            if not match:
+                return True
+            return match[0] == version
+        filter = is_target
+
+        if package_type == 'jars':
+            downloader = Maven()
+            prefix = ''
+        elif package_type in ARROW_REPOSITORY_PACKAGE_TYPES:
+            downloader = Artifactory()
             prefix = f'{package_type}-rc'
         else:
+            downloader = Artifactory()
             prefix = f'{package_type}-rc/{version_string}'
-        files = artifactory.get_file_list(prefix)
-        if package_type in ARROW_REPOSITORY_PACKAGE_TYPES:
-            version_pattern = re.compile(r'\d+\.\d+\.\d+')
-
-            def is_old_release(path):
-                match = version_pattern.search(path)
-                if not match:
-                    return False
-                return match[0] != version
-            files = [x for x in files if not is_old_release(x)]
-        artifactory.download_files(files, re_match=re_match, dest=dest,
-                                   num_parallel=num_parallel)
+            filter = None
+        files = downloader.get_file_list(prefix, filter=filter)
+        downloader.download_files(files, re_match=re_match, dest=dest,
+                                  num_parallel=num_parallel)
 
 
 if __name__ == '__main__':
diff --git a/dev/release/post-03-binary.sh b/dev/release/post-03-binary.sh
index d2a5b01341a..b1b41f9fbea 100755
--- a/dev/release/post-03-binary.sh
+++ b/dev/release/post-03-binary.sh
@@ -49,7 +49,6 @@ fi
 : ${DEPLOY_AMAZON_LINUX:=${DEPLOY_DEFAULT}}
 : ${DEPLOY_CENTOS:=${DEPLOY_DEFAULT}}
 : ${DEPLOY_DEBIAN:=${DEPLOY_DEFAULT}}
-: ${DEPLOY_JAVA:=${DEPLOY_DEFAULT}}
 : ${DEPLOY_NUGET:=${DEPLOY_DEFAULT}}
 : ${DEPLOY_PYTHON:=${DEPLOY_DEFAULT}}
 : ${DEPLOY_UBUNTU:=${DEPLOY_DEFAULT}}
@@ -73,9 +72,6 @@ if [ ${DEPLOY_DEBIAN} -gt 0 ]; then
   rake_tasks+=(apt:release)
   apt_targets+=(debian)
 fi
-if [ ${DEPLOY_JAVA} -gt 0 ]; then
-  rake_tasks+=(java:release)
-fi
 if [ ${DEPLOY_NUGET} -gt 0 ]; then
   rake_tasks+=(nuget:release)
 fi
diff --git a/dev/release/post-09-docs.sh b/dev/release/post-09-docs.sh
index 9c0b77bb51c..35c4be8745b 100755
--- a/dev/release/post-09-docs.sh
+++ b/dev/release/post-09-docs.sh
@@ -43,7 +43,7 @@ popd
 pushd "${ARROW_DIR}"
 git checkout "${release_tag}"
 
-UBUNTU=20.10 archery docker run \
+archery docker run \
   -v "${ARROW_SITE_DIR}/docs:/build/docs" \
   -e ARROW_DOCS_VERSION="${version}" \
   ubuntu-docs
diff --git a/dev/release/post-13-go.sh b/dev/release/post-11-go.sh
similarity index 100%
rename from dev/release/post-13-go.sh
rename to dev/release/post-11-go.sh
diff --git a/dev/release/post-11-java.sh b/dev/release/post-11-java.sh
deleted file mode 100755
index 86e6e9b574f..00000000000
--- a/dev/release/post-11-java.sh
+++ /dev/null
@@ -1,81 +0,0 @@
-#!/usr/bin/env bash
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-set -e
-set -o pipefail
-
-SOURCE_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-
-if [ "$#" -ne 1 ]; then
-  echo "Usage: $0 <version>"
-  exit
-fi
-
-version=$1
-archive_name=apache-arrow-${version}
-tar_gz=${archive_name}.tar.gz
-
-rm -f ${tar_gz}
-curl \
-  --remote-name \
-  --fail \
-  https://downloads.apache.org/arrow/arrow-${version}/${tar_gz}
-rm -rf ${archive_name}
-tar xf ${tar_gz}
-
-pushd ${archive_name}
-
-# clone the testing data to the appropiate directories
-git clone https://github.com/apache/arrow-testing.git testing
-git clone https://github.com/apache/parquet-testing.git cpp/submodules/parquet-testing
-
-# build the jni bindings similarly like the 01-perform.sh does
-mkdir -p cpp/java-build
-pushd cpp/java-build
-cmake \
-  -DARROW_DATASET=ON \
-  -DARROW_FILESYSTEM=ON \
-  -DARROW_GANDIVA_JAVA=ON \
-  -DARROW_GANDIVA=ON \
-  -DARROW_JNI=ON \
-  -DARROW_ORC=ON \
-  -DARROW_PARQUET=ON \
-  -DCMAKE_BUILD_TYPE=release \
-  -G Ninja \
-  ..
-ninja
-popd
-
-# go in the java subfolder
-pushd java
-# stage the artifacts using both the apache-release and arrow-jni profiles
-# Note: on ORC checkstyle failure use -Dcheckstyle.skip=true until https://issues.apache.org/jira/browse/ARROW-12552 gets resolved
-mvn -Papache-release,arrow-jni -Darrow.cpp.build.dir=$(realpath ../cpp/java-build/release) deploy
-popd
-
-popd
-
-echo "Success! The maven artifacts have been stated. Proceed with the following steps:"
-echo "1. Login to the apache repository: https://repository.apache.org/#stagingRepositories"
-echo "2. Select the arrow staging repository you just just created: orgapachearrow-100x"
-echo "3. Click the \"close\" button"
-echo "4. Once validation has passed, click the \"release\" button"
-echo ""
-echo "Note, that you must set up Maven to be able to publish to Apache's repositories."
-echo "Read more at https://www.apache.org/dev/publishing-maven-artifacts.html."
diff --git a/dev/release/verify-release-candidate.sh b/dev/release/verify-release-candidate.sh
index 0f697fa6e27..315258cb692 100755
--- a/dev/release/verify-release-candidate.sh
+++ b/dev/release/verify-release-candidate.sh
@@ -38,14 +38,14 @@ case $# in
      VERSION="$2"
      RC_NUMBER="$3"
      case $ARTIFACT in
-       source|binaries|wheels) ;;
+       source|binaries|wheels|jars) ;;
        *) echo "Invalid argument: '${ARTIFACT}', valid options are \
-'source', 'binaries', or 'wheels'"
+'source', 'binaries', 'wheels', or 'jars'"
           exit 1
           ;;
      esac
      ;;
-  *) echo "Usage: $0 source|binaries X.Y.Z RC_NUMBER"
+  *) echo "Usage: $0 source|binaries|wheels|jars X.Y.Z RC_NUMBER"
      exit 1
      ;;
 esac
@@ -127,7 +127,9 @@ verify_dir_artifact_signatures() {
     if [ -f $base_artifact.sha256 ]; then
       ${sha256_verify} $base_artifact.sha256 || exit 1
     fi
-    ${sha512_verify} $base_artifact.sha512 || exit 1
+    if [ -f $base_artifact.sha512 ]; then
+      ${sha512_verify} $base_artifact.sha512 || exit 1
+    fi
     popd
   done
 }
@@ -729,6 +731,17 @@ test_wheels() {
   popd
 }
 
+test_jars() {
+  local download_dir=jars
+  mkdir -p ${download_dir}
+
+  ${PYTHON:-python} $SOURCE_DIR/download_rc_binaries.py $VERSION $RC_NUMBER \
+         --dest=${download_dir} \
+         --package_type=jars
+
+  verify_dir_artifact_signatures ${download_dir}
+}
+
 # By default test all functionalities.
 # To deactivate one test, deactivate the test and all of its dependents
 # To explicitly select one test, set TEST_DEFAULT=0 TEST_X=1
@@ -737,16 +750,24 @@ test_wheels() {
 # system Node installation, which may be too old.
 : ${INSTALL_NODE:=1}
 
-if [ "${ARTIFACT}" == "source" ]; then
-  : ${TEST_SOURCE:=1}
-elif [ "${ARTIFACT}" == "wheels" ]; then
-  TEST_WHEELS=1
-else
-  TEST_BINARY_DISTRIBUTIONS=1
-fi
+case "${ARTIFACT}" in
+  source)
+    : ${TEST_SOURCE:=1}
+    ;;
+  binaires)
+    TEST_BINARY_DISTRIBUTIONS=1
+    ;;
+  wheels)
+    TEST_WHEELS=1
+    ;;
+  jars)
+    TEST_JARS=1
+    ;;
+esac
 : ${TEST_SOURCE:=0}
-: ${TEST_WHEELS:=0}
 : ${TEST_BINARY_DISTRIBUTIONS:=0}
+: ${TEST_WHEELS:=0}
+: ${TEST_JARS:=0}
 
 : ${TEST_DEFAULT:=1}
 : ${TEST_JAVA:=${TEST_DEFAULT}}
@@ -781,17 +802,28 @@ TEST_JS=$((${TEST_JS} + ${TEST_INTEGRATION_JS}))
 TEST_GO=$((${TEST_GO} + ${TEST_INTEGRATION_GO}))
 TEST_INTEGRATION=$((${TEST_INTEGRATION} + ${TEST_INTEGRATION_CPP} + ${TEST_INTEGRATION_JAVA} + ${TEST_INTEGRATION_JS} + ${TEST_INTEGRATION_GO}))
 
-if [ "${ARTIFACT}" == "source" ]; then
-  NEED_MINICONDA=$((${TEST_CPP} + ${TEST_INTEGRATION}))
-elif [ "${ARTIFACT}" == "wheels" ]; then
-  NEED_MINICONDA=$((${TEST_WHEELS}))
-else
-  if [ -z "${PYTHON:-}" ]; then
-    NEED_MINICONDA=$((${TEST_BINARY}))
-  else
-    NEED_MINICONDA=0
-  fi
-fi
+case "${ARTIFACT}" in
+  source)
+    NEED_MINICONDA=$((${TEST_CPP} + ${TEST_INTEGRATION}))
+    ;;
+  binaries)
+    if [ -z "${PYTHON:-}" ]; then
+      NEED_MINICONDA=$((${TEST_BINARY}))
+    else
+      NEED_MINICONDA=0
+    fi
+    ;;
+  wheels)
+    NEED_MINICONDA=$((${TEST_WHEELS}))
+    ;;
+  jars)
+    if [ -z "${PYTHON:-}" ]; then
+      NEED_MINICONDA=1
+    else
+      NEED_MINICONDA=0
+    fi
+    ;;
+esac
 
 : ${TEST_ARCHIVE:=apache-arrow-${VERSION}.tar.gz}
 case "${TEST_ARCHIVE}" in
@@ -812,32 +844,40 @@ if [ ${NEED_MINICONDA} -gt 0 ]; then
   setup_miniconda
 fi
 
-if [ "${ARTIFACT}" == "source" ]; then
-  dist_name="apache-arrow-${VERSION}"
-  if [ ${TEST_SOURCE} -gt 0 ]; then
-    import_gpg_keys
-    if [ ! -d "${dist_name}" ]; then
-      fetch_archive ${dist_name}
-      tar xf ${dist_name}.tar.gz
-    fi
-  else
-    mkdir -p ${dist_name}
-    if [ ! -f ${TEST_ARCHIVE} ]; then
-      echo "${TEST_ARCHIVE} not found"
-      exit 1
+case "${ARTIFACT}" in
+  source)
+    dist_name="apache-arrow-${VERSION}"
+    if [ ${TEST_SOURCE} -gt 0 ]; then
+      import_gpg_keys
+      if [ ! -d "${dist_name}" ]; then
+        fetch_archive ${dist_name}
+        tar xf ${dist_name}.tar.gz
+      fi
+    else
+      mkdir -p ${dist_name}
+      if [ ! -f ${TEST_ARCHIVE} ]; then
+        echo "${TEST_ARCHIVE} not found"
+        exit 1
+      fi
+      tar xf ${TEST_ARCHIVE} -C ${dist_name} --strip-components=1
     fi
-    tar xf ${TEST_ARCHIVE} -C ${dist_name} --strip-components=1
-  fi
-  pushd ${dist_name}
-  test_source_distribution
-  popd
-elif [ "${ARTIFACT}" == "wheels" ]; then
-  import_gpg_keys
-  test_wheels
-else
-  import_gpg_keys
-  test_binary_distribution
-fi
+    pushd ${dist_name}
+    test_source_distribution
+    popd
+    ;;
+  binaries)
+    import_gpg_keys
+    test_binary_distribution
+    ;;
+  wheels)
+    import_gpg_keys
+    test_wheels
+    ;;
+  jars)
+    import_gpg_keys
+    test_jars
+    ;;
+esac
 
 TEST_SUCCESS=yes
 echo 'Release candidate looks good!'
diff --git a/dev/tasks/docker-tests/azure.linux.yml b/dev/tasks/docker-tests/azure.linux.yml
index dfa07a0d5b4..cff84415850 100644
--- a/dev/tasks/docker-tests/azure.linux.yml
+++ b/dev/tasks/docker-tests/azure.linux.yml
@@ -15,6 +15,8 @@
 # specific language governing permissions and limitations
 # under the License.
 
+{% import 'macros.jinja' as macros with context %}
+
 jobs:
 - job: linux
   pool:
@@ -49,5 +51,16 @@ jobs:
   - script: pip install -e arrow/dev/archery[docker]
     displayName: Setup Archery
 
-  - script: archery docker run -e SETUPTOOLS_SCM_PRETEND_VERSION="{{ arrow.no_rc_version }}" {{ run }}
+  - script: |
+      archery docker run -e SETUPTOOLS_SCM_PRETEND_VERSION="{{ arrow.no_rc_version }}" {{ run }}
     displayName: Execute Docker Build
+
+  {% if post_script is defined %}
+  - script: |
+      {{ post_script|indent(6) }}
+    displayName: Post Script
+  {% endif %}
+
+  {% if artifacts is defined %}
+  {{ macros.azure_upload_releases(artifacts) }}
+  {% endif %}
diff --git a/dev/tasks/python-wheels/github.osx.amd64.yml b/dev/tasks/python-wheels/github.osx.amd64.yml
index 8078abfd56f..88cf85b6ffa 100644
--- a/dev/tasks/python-wheels/github.osx.amd64.yml
+++ b/dev/tasks/python-wheels/github.osx.amd64.yml
@@ -27,11 +27,10 @@ env:
   PYARROW_VERSION: "{{ arrow.no_rc_version }}"
   PYTHON_VERSION: "{{ python_version }}"
   PYTHON: "/Library/Frameworks/Python.framework/Versions/{{ python_version }}/bin/python{{ python_version }}"
-  VCPKG_DEFAULT_TRIPLET: x64-osx-static-release
+  VCPKG_DEFAULT_TRIPLET: amd64-osx-static-release
   VCPKG_FEATURE_FLAGS: "-manifests"
   VCPKG_OVERLAY_TRIPLETS: {{ "${{ github.workspace }}/arrow/ci/vcpkg" }}
   VCPKG_ROOT: {{ "${{ github.workspace }}/vcpkg" }}
-  VCPKG_VERSION: "{{ vcpkg_version }}"
 
 jobs:
   build:
@@ -41,20 +40,33 @@ jobs:
       {{ macros.github_checkout_arrow()|indent }}
 
       - name: Install System Dependencies
-        run: brew install bash bison coreutils ninja cmake
+        run: brew install bash bison coreutils ninja
+
+      - name: Install Specific CMake version
+        uses: lukka/get-cmake@v3.21.2
+
+      - name: Retrieve VCPKG version from arrow/.env
+        shell: bash
+        run: |
+          vcpkg_version=$(cat "arrow/.env" | grep "VCPKG" | cut -d "=" -f2 | tr -d '"')
+          echo "VCPKG_VERSION=$vcpkg_version" >> $GITHUB_ENV
 
       - uses: actions/cache@v2
         id: vcpkg-cache
         with:
           path: vcpkg
-          key: vcpkg-{{ macos_deployment_target }}-{{ vcpkg_version }}-{{ "${{ hashFiles('arrow/ci/vcpkg/*.patch', 'arrow/ci/vcpkg/*osx*.cmake') }}" }}
+          key: vcpkg-{{ macos_deployment_target }}-{{ "${{ env.VCPKG_VERSION }}" }}-{{ "${{ hashFiles('arrow/ci/vcpkg/*.patch', 'arrow/ci/vcpkg/*osx*.cmake') }}" }}
 
       - name: Install Vcpkg
         if: steps.vcpkg-cache.outputs.cache-hit != 'true'
         shell: bash
         env:
           MACOSX_DEPLOYMENT_TARGET: "10.15"
-        run: arrow/ci/scripts/install_vcpkg.sh $VCPKG_VERSION $VCPKG_ROOT
+        run: arrow/ci/scripts/install_vcpkg.sh $VCPKG_ROOT $VCPKG_VERSION
+
+      # workaround for https://github.com/apache/arrow/pull/11569#issuecomment-979592053
+      - name: Install OpenSSL
+        run: $VCPKG_ROOT/vcpkg install openssl
 
       - name: Install Packages
         run: |
@@ -68,6 +80,7 @@ jobs:
             flatbuffers \
             gflags \
             glog \
+            google-cloud-cpp[core,storage] \
             grpc \
             lz4 \
             openssl \
diff --git a/dev/tasks/python-wheels/github.osx.arm64.yml b/dev/tasks/python-wheels/github.osx.arm64.yml
index e5456dbfc28..60a3c61e5b2 100644
--- a/dev/tasks/python-wheels/github.osx.arm64.yml
+++ b/dev/tasks/python-wheels/github.osx.arm64.yml
@@ -39,7 +39,6 @@ env:
   VCPKG_FEATURE_FLAGS: "-manifests"
   VCPKG_OVERLAY_TRIPLETS: {{ "${{ github.workspace }}/arrow/ci/vcpkg" }}
   VCPKG_ROOT: {{ "${{ github.workspace }}/vcpkg" }}
-  VCPKG_VERSION: "{{ vcpkg_version }}"
 
 jobs:
   build:
@@ -56,15 +55,21 @@ jobs:
         shell: bash
         run: echo "/opt/homebrew/opt/bison/bin" >> $GITHUB_PATH
 
+      - name: Retrieve VCPKG version from arrow/.env
+        shell: bash
+        run: |
+          vcpkg_version=$(cat "arrow/.env" | grep "VCPKG" | cut -d "=" -f2 | tr -d '"')
+          echo "VCPKG_VERSION=$vcpkg_version" >> $GITHUB_ENV
+
       - name: Install Vcpkg
         shell: bash
         env:
           MACOSX_DEPLOYMENT_TARGET: "11.0"
-        run: arch -arm64 arrow/ci/scripts/install_vcpkg.sh $VCPKG_VERSION $VCPKG_ROOT
+        run: arch -arm64 arrow/ci/scripts/install_vcpkg.sh $VCPKG_ROOT $VCPKG_VERSION
 
       - name: Install OpenSSL
         shell: bash
-        run: arch -arm64 $VCPKG_ROOT/vcpkg install openssl
+        run: arch -arm64 $VCPKG_ROOT/vcpkg install openssl:arm64-osx-static-release
 
       {% if arch == "universal2" %}
       # OpenSSL doesn't provide an universal2 configuration yet, so vcpkg is
@@ -75,12 +80,13 @@ jobs:
       - name: Create universal binaries for OpenSSL
         shell: bash
         run: |
-          for arch in arm64 x64; do
-            VCPKG_DEFAULT_TRIPLET=${arch}-osx-static-release arch -arm64 $VCPKG_ROOT/vcpkg install openssl
+          mkdir -p $VCPKG_ROOT/installed/universal2-osx-static-release/lib
+          for arch in arm64 amd64; do
+            arch -arm64 $VCPKG_ROOT/vcpkg install openssl:${arch}-osx-static-release
           done
           for lib in libcrypto libssl; do
             lipo -create $VCPKG_ROOT/installed/arm64-osx-static-release/lib/${lib}.a \
-                         $VCPKG_ROOT/installed/x64-osx-static-release/lib/${lib}.a \
+                         $VCPKG_ROOT/installed/amd64-osx-static-release/lib/${lib}.a \
                  -output $VCPKG_ROOT/installed/universal2-osx-static-release/lib/${lib}.a
           done
       {% endif %}
@@ -97,6 +103,7 @@ jobs:
             flatbuffers \
             gflags \
             glog \
+            google-cloud-cpp[core,storage] \
             lz4 \
             orc \
             protobuf \
diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index a4c3d2c9e4f..4b7895576d6 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -60,6 +60,7 @@ groups:
     - python-sdist
     - ubuntu-*
     - wheel-*
+    - test-ubuntu-default-docs
 
 {############################# Testing tasks #################################}
 
@@ -113,6 +114,9 @@ groups:
   verify-rc-binaries:
     - verify-rc-binaries-*
 
+  verify-rc-jars:
+    - verify-rc-jars-*
+
   verify-rc-wheels:
     - verify-rc-wheels-*
 
@@ -384,7 +388,6 @@ tasks:
     ci: github
     template: python-wheels/github.osx.amd64.yml
     params:
-      vcpkg_version: "2021.04.30"
       python_version: "{{ python_version }}"
       macos_deployment_target: "{{ macos_version }}"
       arrow_s3: "{{ arrow_s3 }}"
@@ -416,7 +419,6 @@ tasks:
     params:
       arch: arm64
       arrow_simd_level: "DEFAULT"
-      vcpkg_version: "2021.04.30"
       python_version: "3.8"
       macos_deployment_target: "11.0"
 
@@ -430,7 +432,6 @@ tasks:
     params:
       arch: arm64
       arrow_simd_level: "DEFAULT"
-      vcpkg_version: "2021.04.30"
       python_version: "{{ python_version }}"
       macos_deployment_target: "11.0"
     artifacts:
@@ -444,7 +445,6 @@ tasks:
       # Universal2 builds for both rosetta and native, but we currently can't
       # configure SIMD for both architectures at the same time
       arrow_simd_level: "NONE"
-      vcpkg_version: "2021.04.30"
       python_version: "{{ python_version }}"
       macos_deployment_target: "10.13"
     artifacts:
@@ -833,9 +833,18 @@ tasks:
       env:
         TEST_DEFAULT: 0
         TEST_{{ target|upper }}: 1
-      artifact: {{ target }}
+      artifact: binaries
 {% endfor %}
 
+  verify-rc-jars-amd64:
+    ci: github
+    template: verify-rc/github.linux.amd64.yml
+    params:
+      env:
+        TEST_DEFAULT: 0
+        TEST_JARS: 1
+      artifact: jars
+
 {% for platform, arch, runner in [("linux", "amd64", "ubuntu-20.04"),
                                   ("macos", "amd64", "macos-10.15")] %}
   {% for target in ["cpp",
@@ -985,12 +994,23 @@ tasks:
       image: ubuntu-cpp
 
 {% for debian_version in ["10", "11"] %}
-  test-debian-{{ debian_version }}-cpp:
+  test-debian-{{ debian_version }}-cpp-amd64:
+    ci: github
+    template: docker-tests/github.linux.yml
+    params:
+      env:
+        ARCH: "amd64"
+        DEBIAN: "{{ debian_version }}"
+      image: debian-cpp
+
+  test-debian-{{ debian_version }}-cpp-i386:
     ci: github
     template: docker-tests/github.linux.yml
     params:
       env:
+        ARCH: "i386"
         DEBIAN: "{{ debian_version }}"
+      flags: "-e ARROW_S3=OFF -e ARROW_GANDIVA=OFF"
       image: debian-cpp
 {% endfor %}
 
@@ -1190,7 +1210,6 @@ tasks:
     params:
       env:
         UBUNTU: 21.04
-        CLANG_TOOLS: 9 # can remove this when >=9 is the default
         R_PRUNE_DEPS: TRUE
       flags: '-e ARROW_SOURCE_HOME="/arrow" -e FORCE_BUNDLED_BUILD=TRUE -e LIBARROW_BUILD=TRUE'
       image: ubuntu-r-only-r
@@ -1202,7 +1221,6 @@ tasks:
     params:
       env:
         UBUNTU: 21.04
-        CLANG_TOOLS: 9 # can remove this when >=9 is the default
         GCC_VERSION: 11
       # S3 support is not buildable with gcc11 right now
       flags: '-e ARROW_SOURCE_HOME="/arrow" -e FORCE_BUNDLED_BUILD=TRUE -e LIBARROW_BUILD=TRUE -e ARROW_S3=OFF'
@@ -1256,19 +1274,18 @@ tasks:
         GO: 1.15
       run: debian-go
 
-  test-ubuntu-20.10-docs:
-    ci: azure
-    template: docker-tests/azure.linux.yml
-    params:
-      env:
-        UBUNTU: "20.10"
-      run: ubuntu-docs
-
   test-ubuntu-default-docs:
     ci: azure
     template: docker-tests/azure.linux.yml
     params:
-      run: ubuntu-docs
+      artifacts: "build/docs.tar.gz"
+      post_script: |
+        cd build
+        sudo chown -R ${USER}: .
+        tar cvzf docs.tar.gz docs
+      run: "-v $PWD/build/:/build/ ubuntu-docs"
+    artifacts:
+      - docs.tar.gz
 
   ############################## Fuzz tests #################################
 
diff --git a/docker-compose.yml b/docker-compose.yml
index d13ea677553..9bf5bd0841d 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -97,6 +97,7 @@ x-hierarchy:
   # service entry, so any new image/service must be listed here.
   - conda:
     - conda-cpp:
+      - conda-integration
       - conda-cpp-hiveserver2
       - conda-cpp-valgrind
       - conda-python:
@@ -108,7 +109,7 @@ x-hierarchy:
         - conda-python-turbodbc
         - conda-python-kartothek
         - conda-python-spark
-    - conda-integration
+
   - debian-cpp:
     - debian-c-glib:
       - debian-ruby
@@ -203,7 +204,6 @@ services:
         - ${REPO}:${ARCH}-conda
       args:
         arch: ${ARCH}
-        prefix: /opt/conda
     volumes:
       - .:/arrow:delegated
 
@@ -236,11 +236,12 @@ services:
       ARROW_MIMALLOC: "ON"
       ARROW_USE_LD_GOLD: "ON"
       ARROW_USE_PRECOMPILED_HEADERS: "ON"
+      BUILD_DOCS_PYTHON: "ON"
     volumes: &conda-volumes
       - .:/arrow:delegated
       - ${DOCKER_VOLUME_PREFIX}conda-ccache:/ccache:delegated
     command:
-      ["/arrow/ci/scripts/cpp_build.sh /arrow /build true &&
+      ["/arrow/ci/scripts/cpp_build.sh /arrow /build &&
         /arrow/ci/scripts/cpp_test.sh /arrow /build"]
 
   conda-cpp-valgrind:
@@ -259,7 +260,6 @@ services:
       args:
         repo: ${REPO}
         arch: ${ARCH}
-        prefix: /opt/conda
     shm_size: *shm-size
     environment:
       <<: *ccache
@@ -514,7 +514,7 @@ services:
     ulimits: *ulimits
     environment:
       <<: *ccache
-      ARROW_GLIB_GTK_DOC: "true"
+      BUILD_DOCS_C_GLIB: "ON"
     volumes: *debian-volumes
     command: &c-glib-command >
       /bin/bash -c "
@@ -542,7 +542,6 @@ services:
     ulimits: *ulimits
     environment:
       <<: *ccache
-      ARROW_GLIB_GTK_DOC: "true"
     volumes: *ubuntu-volumes
     command: *c-glib-command
 
@@ -573,6 +572,7 @@ services:
     ulimits: *ulimits
     environment:
       <<: *ccache
+      BUILD_DOCS_C_GLIB: "ON"
     volumes: *debian-volumes
     command: &ruby-command >
       /bin/bash -c "
@@ -786,18 +786,18 @@ services:
     image: ${REPO}:${ARCH}-python-${PYTHON}-wheel-manylinux-2010-vcpkg-${VCPKG}
     build:
       args:
-        arch_alias: ${ARCH_ALIAS}
-        arch_short_alias: ${ARCH_SHORT_ALIAS}
+        arch: ${ARCH}
+        arch_short: ${ARCH_SHORT}
         base: quay.io/pypa/manylinux2010_${ARCH_ALIAS}:2021-10-11-14ac00e
         vcpkg: ${VCPKG}
         python: ${PYTHON}
+        manylinux: 2010
       context: .
       dockerfile: ci/docker/python-wheel-manylinux-201x.dockerfile
       cache_from:
         - ${REPO}:${ARCH}-python-${PYTHON}-wheel-manylinux-2010-vcpkg-${VCPKG}
     environment:
       <<: *ccache
-      MANYLINUX_VERSION: 2010
     volumes:
       - .:/arrow:delegated
       - ${DOCKER_VOLUME_PREFIX}python-wheel-manylinux2010-ccache:/ccache:delegated
@@ -809,18 +809,18 @@ services:
     image: ${REPO}:${ARCH}-python-${PYTHON}-wheel-manylinux-2014-vcpkg-${VCPKG}
     build:
       args:
-        arch_alias: ${ARCH_ALIAS}
-        arch_short_alias: ${ARCH_SHORT_ALIAS}
-        base:  quay.io/pypa/manylinux2014_${ARCH_ALIAS}:2021-10-11-14ac00e
+        arch: ${ARCH}
+        arch_short: ${ARCH_SHORT}
+        base: quay.io/pypa/manylinux2014_${ARCH_ALIAS}:2021-10-11-14ac00e
         vcpkg: ${VCPKG}
         python: ${PYTHON}
+        manylinux: 2014
       context: .
       dockerfile: ci/docker/python-wheel-manylinux-201x.dockerfile
       cache_from:
         - ${REPO}:${ARCH}-python-${PYTHON}-wheel-manylinux-2014-vcpkg-${VCPKG}
     environment:
       <<: *ccache
-      MANYLINUX_VERSION: 2014
     volumes:
       - .:/arrow:delegated
       - ${DOCKER_VOLUME_PREFIX}python-wheel-manylinux2014-ccache:/ccache:delegated
@@ -940,8 +940,12 @@ services:
     shm_size: *shm-size
     environment:
       <<: *ccache
+      BUILD_DOCS_PYTHON: "ON"
     volumes: *conda-volumes
-    command: *python-conda-command
+    command:
+      ["/arrow/ci/scripts/cpp_build.sh /arrow /build &&
+        /arrow/ci/scripts/python_build.sh /arrow /build &&
+        /arrow/ci/scripts/python_test.sh /arrow"]
 
   conda-python-dask:
     # Possible $DASK parameters:
@@ -1289,8 +1293,6 @@ services:
     command: >
       /bin/bash -c "/arrow/ci/scripts/r_revdepcheck.sh /arrow"
 
-
-
   ################################# Go ########################################
 
   debian-go:
@@ -1366,9 +1368,11 @@ services:
         node: ${NODE}
     shm_size: *shm-size
     volumes: *debian-volumes
+    environment:
+      BUILD_DOCS_JS: "ON"
     command: &js-command >
       /bin/bash -c "
-        /arrow/ci/scripts/js_build.sh /arrow &&
+        /arrow/ci/scripts/js_build.sh /arrow /build &&
         /arrow/ci/scripts/js_test.sh /arrow"
 
   #################################### C# #####################################
@@ -1507,18 +1511,22 @@ services:
     environment:
       <<: *ccache
       ARROW_CUDA: "ON"
-      ARROW_GLIB_GTK_DOC: "true"
+      BUILD_DOCS_C_GLIB: "ON"
+      BUILD_DOCS_CPP: "ON"
+      BUILD_DOCS_JAVA: "ON"
+      BUILD_DOCS_JS: "ON"
+      BUILD_DOCS_PYTHON: "ON"
+      BUILD_DOCS_R: "ON"
       Protobuf_SOURCE: "BUNDLED"  # Need Protobuf >= 3.15
     volumes: *ubuntu-volumes
     command: &docs-command >
       /bin/bash -c "
-        /arrow/ci/scripts/cpp_build.sh /arrow /build true &&
+        /arrow/ci/scripts/cpp_build.sh /arrow /build &&
         /arrow/ci/scripts/c_glib_build.sh /arrow /build &&
         /arrow/ci/scripts/python_build.sh /arrow /build &&
-        /arrow/ci/scripts/java_build.sh /arrow /build true &&
-        /arrow/ci/scripts/js_build.sh /arrow true &&
-        /arrow/ci/scripts/r_build.sh /arrow true &&
-        /arrow/ci/scripts/docs_build.sh /arrow /build"
+        /arrow/ci/scripts/r_build.sh /arrow /build &&
+        /arrow/ci/scripts/js_build.sh /arrow /build &&
+        /arrow/ci/scripts/java_build.sh /arrow /build"
 
   ################################# Tools #####################################
 
diff --git a/docs/source/_static/theme_overrides.css b/docs/source/_static/theme_overrides.css
index d7d0bdfdbe1..6bc5f707036 100644
--- a/docs/source/_static/theme_overrides.css
+++ b/docs/source/_static/theme_overrides.css
@@ -96,7 +96,6 @@ Details: min(15vh, 110px) for the logo size, 8rem for search box etc*/
 /* Styling to get the version dropdown and search box side-by-side on wide screens */
 
 #version-search-wrapper {
-  overflow: hidden;
   width: inherit;
   display: flex;
   flex-wrap: wrap;
diff --git a/docs/source/cpp/arrays.rst b/docs/source/cpp/arrays.rst
index ff76e9d027a..9c1bade551b 100644
--- a/docs/source/cpp/arrays.rst
+++ b/docs/source/cpp/arrays.rst
@@ -84,7 +84,7 @@ The resulting Array (which can be casted to the concrete :class:`arrow::Int64Arr
 subclass if you want to access its values) then consists of two
 :class:`arrow::Buffer`\s.
 The first buffer holds the null bitmap, which consists here of a single byte with
-the bits ``1|1|1|1|0|1|1|1``. As we use  `least-significant bit (LSB) numbering`_.
+the bits ``1|1|1|1|0|1|1|1``. As we use  `least-significant bit (LSB) numbering`_,
 this indicates that the fourth entry in the array is null. The second
 buffer is simply an ``int64_t`` array containing all the above values.
 As the fourth entry is null, the value at that position in the buffer is
@@ -95,7 +95,7 @@ Here is how you could access the concrete array's contents::
    // Cast the Array to its actual type to access its data
    auto int64_array = std::static_pointer_cast<arrow::Int64Array>(array);
 
-   // Get the pointer to the null bitmap.
+   // Get the pointer to the null bitmap
    const uint8_t* null_bitmap = int64_array->null_bitmap_data();
 
    // Get the pointer to the actual data
diff --git a/docs/source/developers/cpp/building.rst b/docs/source/developers/cpp/building.rst
index 3702e6e713d..0258412b554 100644
--- a/docs/source/developers/cpp/building.rst
+++ b/docs/source/developers/cpp/building.rst
@@ -43,7 +43,7 @@ Building requires:
 * On Linux and macOS, either ``make`` or ``ninja`` build utilities
 * At least 1GB of RAM for a minimal build, 4GB for a minimal  
   debug build with tests and 8GB for a full build using
-  :ref:`docker <docker>`.
+  :ref:`docker <docker-builds>`.
 
 On Ubuntu/Debian you can install the requirements with:
 
@@ -121,6 +121,106 @@ On MSYS2:
 Building
 ========
 
+All the instructions below assume that you have cloned the Arrow git
+repository and navigated to the ``cpp`` subdirectory:
+
+.. code-block:: shell
+
+   $ git clone https://github.com/apache/arrow.git
+   $ cd arrow/cpp
+
+CMake presets
+-------------
+
+Using CMake version 3.21.0 or higher, some presets for various build
+configurations are provided.  You can get a list of the available presets
+using ``cmake --list-presets``:
+
+.. code-block:: shell
+
+   $ cmake --list-presets   # from inside the `cpp` subdirectory
+   Available configure presets:
+
+     "ninja-debug-minimal"     - Debug build without anything enabled
+     "ninja-debug-basic"       - Debug build with tests and reduced dependencies
+     "ninja-debug"             - Debug build with tests and more optional components
+      [ etc. ]
+
+You can inspect the specific options enabled by a given preset using
+``cmake -N --preset <preset name>``:
+
+.. code-block:: shell
+
+   $ cmake --preset -N ninja-debug-minimal
+   Preset CMake variables:
+
+     ARROW_BUILD_INTEGRATION="OFF"
+     ARROW_BUILD_STATIC="OFF"
+     ARROW_BUILD_TESTS="OFF"
+     ARROW_EXTRA_ERROR_CONTEXT="ON"
+     ARROW_WITH_RE2="OFF"
+     ARROW_WITH_UTF8PROC="OFF"
+     CMAKE_BUILD_TYPE="Debug"
+
+You can also create a build from a given preset:
+
+.. code-block:: shell
+
+   $ mkdir build   # from inside the `cpp` subdirectory
+   $ cd build
+   $ cmake .. --preset ninja-debug-minimal
+      Preset CMake variables:
+
+        ARROW_BUILD_INTEGRATION="OFF"
+        ARROW_BUILD_STATIC="OFF"
+        ARROW_BUILD_TESTS="OFF"
+        ARROW_EXTRA_ERROR_CONTEXT="ON"
+        ARROW_WITH_RE2="OFF"
+        ARROW_WITH_UTF8PROC="OFF"
+        CMAKE_BUILD_TYPE="Debug"
+
+      -- Building using CMake version: 3.21.3
+      [ etc. ]
+
+and then ask to compile the build targets:
+
+.. code-block:: shell
+
+   $ cmake --build .
+   [142/142] Creating library symlink debug/libarrow.so.700 debug/libarrow.so
+
+   $ tree debug/
+   debug/
+   ├── libarrow.so -> libarrow.so.700
+   ├── libarrow.so.700 -> libarrow.so.700.0.0
+   └── libarrow.so.700.0.0
+
+   0 directories, 3 files
+
+When creating a build, it is possible to pass custom options besides
+the preset-defined ones, for example:
+
+.. code-block:: shell
+
+   $ cmake .. --preset ninja-debug-minimal -DCMAKE_INSTALL_PREFIX=/usr/local
+
+.. note::
+   The CMake presets are provided as a help to get started with Arrow
+   development and understand common build configurations.  They are not
+   guaranteed to be immutable but may change in the future based on
+   feedback.
+
+   Instead of relying on CMake presets, it is **highly recommended** that
+   automated builds, continuous integration, release scripts, etc. use
+   manual configuration, as outlined below.
+
+.. seealso::
+   `Official documentation for CMake presets <https://cmake.org/cmake/help/v3.21/manual/cmake-presets.7.html>`_.
+
+
+Manual configuration
+--------------------
+
 The build system uses ``CMAKE_BUILD_TYPE=release`` by default, so if this
 argument is omitted then a release build will be produced.
 
@@ -145,45 +245,34 @@ Minimal release build (1GB of RAM for building or more recommended):
 
 .. code-block:: shell
 
-   git clone https://github.com/apache/arrow.git
-   cd arrow/cpp
-   mkdir release
-   cd release
-   cmake ..
-   make
+   $ mkdir build-release
+   $ cd build-release
+   $ cmake ..
+   $ make -j8       # if you have 8 CPU cores, otherwise adjust
 
 Minimal debug build with unit tests (4GB of RAM for building or more recommended):
 
 .. code-block:: shell
 
-   git clone https://github.com/apache/arrow.git
-   cd arrow
-   git submodule update --init --recursive
-   export ARROW_TEST_DATA=$PWD/testing/data
-   cd cpp
-   mkdir debug
-   cd debug
-   cmake -DCMAKE_BUILD_TYPE=Debug -DARROW_BUILD_TESTS=ON ..
-   make unittest
+   $ git submodule update --init --recursive
+   $ export ARROW_TEST_DATA=$PWD/../testing/data
+   $ mkdir build-debug
+   $ cd build-debug
+   $ cmake -DCMAKE_BUILD_TYPE=Debug -DARROW_BUILD_TESTS=ON ..
+   $ make -j8       # if you have 8 CPU cores, otherwise adjust
+   $ make unittest  # to run the tests
 
 The unit tests are not built by default. After building, one can also invoke
 the unit tests using the ``ctest`` tool provided by CMake (note that ``test``
 depends on ``python`` being available).
 
-CMake 
-`UNITY_BUILD <https://cmake.org/cmake/help/latest/prop_tgt/UNITY_BUILD.html/>`_
-can increase memory requirements to complete a build, so in memory constrained
-environments it should be turned off.
-
-* ``-DCMAKE_UNITY_BUILD=OFF``: Combine source files during building
-
 On some Linux distributions, running the test suite might require setting an
 explicit locale. If you see any locale-related errors, try setting the
 environment variable (which requires the `locales` package or equivalent):
 
 .. code-block:: shell
 
-   export LC_ALL="en_US.UTF-8"
+   $ export LC_ALL="en_US.UTF-8"
 
 Faster builds with Ninja
 ~~~~~~~~~~~~~~~~~~~~~~~~
@@ -193,6 +282,15 @@ get faster builds. It especially speeds up incremental builds. To use
 ``ninja``, pass ``-GNinja`` when calling ``cmake`` and then use the ``ninja``
 command instead of ``make``.
 
+Unity builds
+~~~~~~~~~~~~
+
+The CMake
+`unity builds <https://cmake.org/cmake/help/latest/prop_tgt/UNITY_BUILD.html/>`_
+option can make full builds significantly faster, but it also increases the
+memory requirements.  Consider turning it on (using ``-DCMAKE_UNITY_BUILD=ON``)
+if memory consumption is not an issue.
+
 Optional Components
 ~~~~~~~~~~~~~~~~~~~
 
@@ -300,7 +398,7 @@ CMake:
 LLVM and Clang Tools
 ~~~~~~~~~~~~~~~~~~~~
 
-We are currently using LLVM 8 for library builds and for other developer tools
+We are currently using LLVM for library builds and for other developer tools
 such as code formatting with ``clang-format``. LLVM can be installed via most
 modern package managers (apt, yum, conda, Homebrew, vcpkg, chocolatey).
 
@@ -355,7 +453,7 @@ environment (detected by presence of the ``$CONDA_PREFIX`` environment
 variable), in which case it is ``CONDA``.
 
 Individual Dependency Resolution
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------------
 
 While ``-DARROW_DEPENDENCY_SOURCE=$SOURCE`` sets a global default for all
 packages, the resolution strategy can be overridden for individual packages by
@@ -371,7 +469,7 @@ is listed above, but the most up-to-date listing can be found in
 `cpp/cmake_modules/ThirdpartyToolchain.cmake <https://github.com/apache/arrow/blob/master/cpp/cmake_modules/ThirdpartyToolchain.cmake>`_.
 
 Bundled Dependency Versions
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
+---------------------------
 
 When using the ``BUNDLED`` method to build a dependency from source, the
 version number from ``cpp/thirdparty/versions.txt`` is used. There is also a
@@ -384,7 +482,7 @@ Arrow libraries in a third party project is more complex. See below for
 instructions about how to configure your build system in this case.
 
 Boost-related Options
-~~~~~~~~~~~~~~~~~~~~~
+---------------------
 
 We depend on some Boost C++ libraries for cross-platform support. In most cases,
 the Boost version available in your package manager may be new enough, and the
@@ -394,7 +492,7 @@ non-standard location, you can specify it by passing
 variable.
 
 Offline Builds
-~~~~~~~~~~~~~~
+--------------
 
 If you do not use the above variables to direct the Arrow build system to
 preinstalled dependencies, they will be built automatically by the Arrow build
@@ -422,7 +520,7 @@ declared environment variable pointing to downloaded archives instead of
 downloading them (one for each build dir!).
 
 Statically Linking
-~~~~~~~~~~~~~~~~~~
+------------------
 
 When ``-DARROW_BUILD_STATIC=ON``, all build dependencies built as static
 libraries by the Arrow build system will be merged together to create a static
@@ -451,7 +549,7 @@ this can be accomplished with the ``Threads`` built-in package:
 .. _cpp-extra-debugging:
 
 Extra debugging help
-~~~~~~~~~~~~~~~~~~~~
+--------------------
 
 If you use the CMake option ``-DARROW_EXTRA_ERROR_CONTEXT=ON`` it will compile
 the libraries with extra debugging information on error checks inside the
@@ -473,14 +571,14 @@ outputs like:
    NotImplemented: Unable to convert type: decimal(19, 4)
 
 Deprecations and API Changes
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+----------------------------
 
 We use the compiler definition ``ARROW_NO_DEPRECATED_API`` to disable APIs that
 have been deprecated. It is a good practice to compile third party applications
 with this flag to proactively catch and account for API changes.
 
 Modular Build Targets
-~~~~~~~~~~~~~~~~~~~~~
+---------------------
 
 Since there are several major parts of the C++ project, we have provided
 modular CMake targets for building each library component, group of unit tests
@@ -516,7 +614,7 @@ If you omit an explicit target when invoking ``make``, all targets will be
 built.
 
 Debugging with Xcode on macOS
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-----------------------------
 
 Xcode is the IDE provided with macOS and can be use to develop and debug Arrow
 by generating an Xcode project:
diff --git a/docs/source/developers/cpp/development.rst b/docs/source/developers/cpp/development.rst
index 4098f1c4e67..bd9e47f14ed 100644
--- a/docs/source/developers/cpp/development.rst
+++ b/docs/source/developers/cpp/development.rst
@@ -105,9 +105,11 @@ following checks:
   subcommand to :ref:`Archery <archery>`. This can also be fixed locally
   by running ``archery lint --cpplint --fix``.
 
-In order to account for variations in the behavior of ``clang-format`` between
-major versions of LLVM, we pin the version of ``clang-format`` used (current
-LLVM 8).
+In order to account for variations in the behavior of ``clang-format``
+between major versions of LLVM, we pin the version of ``clang-format``
+used. You can confirm the current pinned version by finding
+the ``CLANG_TOOLS`` variable value in `.env
+<https://github.com/apache/arrow/blob/master/.env>`_.
 
 Depending on how you installed clang-format, the build system may not be able
 to find it. You can provide an explicit path to your LLVM installation (or the
diff --git a/docs/source/developers/cpp/fuzzing.rst b/docs/source/developers/cpp/fuzzing.rst
index 41398a13dc2..d0c6b2357a1 100644
--- a/docs/source/developers/cpp/fuzzing.rst
+++ b/docs/source/developers/cpp/fuzzing.rst
@@ -15,6 +15,8 @@
 .. specific language governing permissions and limitations
 .. under the License.
 
+.. _cpp-fuzzing:
+
 =================
 Fuzzing Arrow C++
 =================
diff --git a/docs/source/developers/reviewing.rst b/docs/source/developers/reviewing.rst
new file mode 100644
index 00000000000..3b036931172
--- /dev/null
+++ b/docs/source/developers/reviewing.rst
@@ -0,0 +1,257 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied.  See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+=======================
+Reviewing contributions
+=======================
+
+Principles
+==========
+
+Arrow is a foundational project that will need to evolve over many years
+or even decades, while serving potentially millions of users.  We believe
+that being meticulous when reviewing brings greater rewards to the project
+than being lenient and aiming for quick merges.
+
+Code reviews like this lead to better quality code, more people who are
+engaged with and understand the code being changed, and a generally
+healthier project with more room to grow and accommodate emerging needs.
+
+
+Guidelines
+==========
+
+Meta
+----
+
+**Use your own judgement**.  These guidelines are not hard rules.
+Committers are expected to have sufficient expertise on their work
+areas to be able to adjust their approach based on any concerns they have.
+
+These guidelines are not listed in a particular order and are not intended
+to be used as a checklist.
+
+Finally, these guidelines are not exhaustive.
+
+Scope and completeness
+----------------------
+
+* Our general policy is to not introduce regressions or merge PRs that require
+  follow-ons to function correctly (though exceptions to this can be made).
+  Making necessary changes after a merge is more costly both for the
+  contributor and the reviewer, but also for other developers who may be
+  confused if they hit problems introduced by a merged PR.
+
+* What changes are in-scope for a PR and what changes might/could/should be
+  pushed out of scope and have a follow-up JIRA created should be determined
+  in collaboration between the authors and the reviewers.
+
+* When a large piece of functionality is being contributed and it seems
+  desirable to integrate it piecewise, favour functional cohesion when
+  deciding how to divide changes (for example, if a filesystem implementation
+  is being contributed, a first PR may contribute directory metadata
+  operations, a second PR file reading facilities and a third PR file writing
+  facilities).
+
+Public API design
+-----------------
+
+* Public APIs should nudge users towards the most desirable constructs.
+  In other words, if there is a "best" way to do something, it should
+  ideally also be the most easily discoverable and the most concise to type.
+  For example, safe APIs should be featured more prominently than
+  unsafe APIs that may crash or silently produce erroneous results on
+  invalid input.
+
+* Public APIs should ideally tend to produce readable code.  One example
+  is when multiple options are expected to be added over time: it is better
+  to try to organize options logically rather than juxtapose them all in
+  a function's signature (see for example the CSV reading APIs in
+  :ref:`C++ <cpp-api-csv>` and :ref:`Python <py-api-csv>`).
+
+* Naming is important.  Try to ask yourself if code calling the new API
+  would be understandable without having to read the API docs.
+  Vague naming should be avoided; inaccurate naming is even worse as it
+  can mislead the reader and lead to buggy user code.
+
+* Be mindful of terminology.  Every project has (explicitly or tacitly) set
+  conventions about how to name important concepts; steering away from those
+  conventions increases the cognitive workload both for contributors and
+  users of the project.  Conversely, reusing a well-known term for a different
+  purpose than usual can also increase the cognitive workload and make
+  developers' lives more difficult.
+
+* If you are unsure whether an API is the right one for the task at hand,
+  it is advisable to mark it experimental, such that users know that it
+  may be changed over time, while contributors are less wary of bringing
+  code-breaking improvements.  However, experimental APIs should not be
+  used as an excuse for eschewing basic API design principles.
+
+Robustness
+----------
+
+* Arrow is a set of open source libraries that will be used in a very wide
+  array of contexts (including fiddling with deliberately artificial data
+  at a Jupyter interpreter prompt).  If you are writing a public API, make
+  sure that it won't crash or produce undefined behaviour on unusual (but
+  valid) inputs.
+
+* When a non-trivial algorithm is implemented, defensive coding can
+  be useful to catch potential problems (such as debug-only assertions, if
+  the language allows them).
+
+* APIs ingesting potentially untrusted data, such as on-disk file formats,
+  should try to avoid crashing or produce silent bugs when invalid or
+  corrupt data is fed to them.  This can require a lot of care that is
+  out of the scope of regular code reviews (such as setting up
+  :ref:`fuzz testing <cpp-fuzzing>`), but basic checks can still be
+  suggested at the code review stage.
+
+* When calling foreign APIs, especially system functions or APIs dealing with
+  input / output, do check for errors and propagate them (if the language
+  does not propagate errors automatically, such as C++).
+
+Performance
+-----------
+
+* Think about performance, but do not obsess over it.  Algorithmic complexity
+  is important if input size may be "large" (the meaning of large depends
+  on the context: use your own expertise to decide!).  Micro-optimizations
+  improving performance by 20% or more on performance-sensitive functionality
+  may be useful as well; lesser micro-optimizations may not be worth the
+  time spent on them, especially if they lead to more complicated code.
+
+* If performance is important, measure it.  Do not satisfy yourself with
+  guesses and intuitions (which may be founded on incorrect assumptions
+  about the compiler or the hardware).
+
+  .. seealso:: :ref:`Benchmarking Arrow <benchmarks>`
+
+* Try to avoid trying to trick the compiler/interpreter/runtime by writing
+  the code in a certain way, unless it's really important.  These tricks
+  are generally brittle and dependent on platform details that may become
+  obsolete, and they can make code harder to maintain (a common question
+  that can block contributors is "what should I do about this weird hack
+  that my changes would like to remove"?).
+
+* Avoiding rough edges or degenerate behaviour (such as memory blowups when
+  a size estimate is inaccurately large) may be more important than trying to
+  improve the common case by a small amount.
+
+Documentation
+-------------
+
+These guidelines should ideally apply to both prose documentation and
+in-code docstrings.
+
+* Look for ambiguous / poorly informative wording.  For example, *"it is an
+  error if ..."* is less informative than either *"An error is raised if ... "*
+  or *"Behaviour is undefined if ..."* (the first phrasing doesn't tell the
+  reader what actually *happens* on such an error).
+
+* When reviewing documentation changes (or prose snippets, in general),
+  be mindful about spelling, grammar, expression, and concision.  Clear
+  communication is essential for effective collaboration with people
+  from a wide range of backgrounds, and contributes to better documentation.
+
+* Some contributors do not have English as a native language (and perhaps
+  neither do you).  It is advised to help them and/or ask for external help
+  if needed.
+
+* Cross-linking increases the global value of documentation.  Sphinx especially
+  has great cross-linking capabilities (including topic references, glossary
+  terms, API references), so be sure to make use of them!
+
+Testing
+-------
+
+* When adding an API, all nominal cases should have test cases.  Does a function
+  allow null values? Then null values should be tested (alongside non-null
+  values, of course). Does a function allow different input types? etc.
+
+* If some aspect of a functionality is delicate (either by definition or
+  as an implementation detail), it should be tested.
+
+* Corner cases should be exercised, especially in low-level implementation
+  languages such as C++.  Examples: empty arrays, zero-chunk arrays, arrays
+  with only nulls, etc.
+
+* Stress tests can be useful, for example to uncover synchronizations bugs
+  if non-trivial parallelization is being added, or to validate a computational
+  argument against a slow and straightforward reference implementation.
+
+* A mitigating concern, however, is the overall cost of running the test
+  suite.  Continuous Integration (CI) runtimes can be painfully long and
+  we should be wary of increasing them too much.  Sometimes it is
+  worthwhile to fine-tune testing parameters to balance the usefulness
+  of tests against the cost of running them (especially where stress tests
+  are involved, since they tend to imply execution over large datasets).
+
+
+Social aspects
+==============
+
+* Reviewing is a communication between the contributor and the reviewer.
+  Avoid letting questions or comments remain unanswered for too long
+  ("too long" is of course very subjective, but two weeks can be a reasonable
+  heuristic).  If you cannot allocate time soon, do say it explicitly.
+  If you don't have the answer to a question, do say it explicitly.
+  Saying *"I don't have time immediately but I will come back later,
+  feel free to ping if I seem to have forgotten"* or *"Sorry, I am out of
+  my depth here"* is always better than saying nothing and leaving the
+  other person wondering.
+
+* If you know someone who has the competence to help on a blocking issue
+  and past experience suggests they may be willing to do so, feel free to
+  add them to the discussion (for example by gently pinging their Github
+  handle).
+
+* If the contributor has stopped giving feedback or updating their PR,
+  perhaps they're not interested any more, but perhaps also they're stuck
+  on some issue and feel unable to push their contribution any further.
+  Don't hesitate to ask (*"I see this PR hasn't seen any updates recently,
+  are you stuck on something? Do you need any help?"*).
+
+* If the contribution is genuinely desirable and the contributor is not making
+  any progress, it is also possible to take it up.  Out of politeness,
+  it is however better to ask the contributor first.
+
+* Some contributors are looking for a quick fix to a specific problem and
+  don't want to spend too much time on it.  Others on the contrary are eager
+  to learn and improve their contribution to make it conform to the
+  project's standards.  The latter kind of contributors are especially
+  valuable as they may become long-term contributors or even committers
+  to the project.
+
+* Some contributors may respond *"I will fix it later, can we merge anyway?"*
+  when a problem is pointed out to them.  Unfortunately, whether the fix will
+  really be contributed soon in a later PR is difficult to predict or enforce.
+  If the contributor has previously demonstrated that they are reliable,
+  it may be acceptable to do as suggested.  Otherwise, it is better to
+  decline the suggestion.
+
+* If a PR is generally ready for merge apart from trivial or uncontroversial
+  concerns, the reviewer may decide to push changes themselves to the
+  PR instead of asking the contributor to make the changes.
+
+* Ideally, contributing code should be a rewarding process.  Of course,
+  it will not always be, but we should strive to reduce contributor
+  frustration while keeping the above issues in mind.
+
+* Like any communication, code reviews are governed by the Apache
+  `Code of Conduct <https://www.apache.org/foundation/policies/conduct.html>`_.
+  This applies to both reviewers and contributors.
diff --git a/docs/source/index.rst b/docs/source/index.rst
index 5b907dcda4c..f96a287b64f 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -87,6 +87,7 @@ target environment.**
 
    developers/contributing
    developers/guide/index
+   developers/reviewing
    developers/cpp/index
    developers/python
    developers/archery
diff --git a/docs/source/python/api/formats.rst b/docs/source/python/api/formats.rst
index fdc28040a71..1959b641651 100644
--- a/docs/source/python/api/formats.rst
+++ b/docs/source/python/api/formats.rst
@@ -18,7 +18,7 @@
 Tabular File Formats
 ====================
 
-.. _api.csv:
+.. _py-api-csv:
 
 CSV Files
 ---------
diff --git a/docs/source/python/csv.rst b/docs/source/python/csv.rst
index 1724c63f417..a9f3e3c9ca8 100644
--- a/docs/source/python/csv.rst
+++ b/docs/source/python/csv.rst
@@ -16,7 +16,7 @@
 .. under the License.
 
 .. currentmodule:: pyarrow.csv
-.. _csv:
+.. _py-csv:
 
 Reading and Writing CSV files
 =============================
diff --git a/docs/source/python/getstarted.rst b/docs/source/python/getstarted.rst
index 78c43c8eb7f..4f134f2a263 100644
--- a/docs/source/python/getstarted.rst
+++ b/docs/source/python/getstarted.rst
@@ -93,7 +93,7 @@ data will be as quick as possible
 
 Saving and loading back data in arrow is usually done through
 :ref:`Parquet <parquet>`, :ref:`IPC format <ipc>` (:ref:`feather`), 
-:ref:`CSV <csv>` or :ref:`Line-Delimited JSON <json>` formats.
+:ref:`CSV <py-csv>` or :ref:`Line-Delimited JSON <json>` formats.
 
 Performing Computations
 -----------------------
diff --git a/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/GeneralOutOfPlaceVectorSorter.java b/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/GeneralOutOfPlaceVectorSorter.java
new file mode 100644
index 00000000000..9ea39f638ae
--- /dev/null
+++ b/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/GeneralOutOfPlaceVectorSorter.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.arrow.algorithm.sort;
+
+import org.apache.arrow.util.Preconditions;
+import org.apache.arrow.vector.IntVector;
+import org.apache.arrow.vector.ValueVector;
+
+/**
+ * An out-of-place sorter for vectors of arbitrary type, with time complexity O(n*log(n)).
+ * Since it does not make any assumptions about the memory layout of the vector, its performance
+ * can be sub-optimal. So if another sorter is applicable ({@link FixedWidthInPlaceVectorSorter}),
+ * it should be used in preference.
+ *
+ * @param <V> vector type.
+ */
+public class GeneralOutOfPlaceVectorSorter<V extends ValueVector> implements OutOfPlaceVectorSorter<V> {
+
+  @Override
+  public void sortOutOfPlace(V srcVector, V dstVector, VectorValueComparator<V> comparator) {
+    comparator.attachVector(srcVector);
+
+    // check vector capacity
+    Preconditions.checkArgument(dstVector.getValueCapacity() >= srcVector.getValueCount(),
+        "Not enough capacity for the target vector. " +
+            "Expected capacity %s, actual capacity %s", srcVector.getValueCount(), dstVector.getValueCapacity());
+
+    // sort value indices
+    try (IntVector sortedIndices = new IntVector("", srcVector.getAllocator())) {
+      sortedIndices.allocateNew(srcVector.getValueCount());
+      sortedIndices.setValueCount(srcVector.getValueCount());
+
+      IndexSorter<V> indexSorter = new IndexSorter<>();
+      indexSorter.sort(srcVector, sortedIndices, comparator);
+
+      // copy sorted values to the output vector
+      for (int dstIndex = 0; dstIndex < sortedIndices.getValueCount(); dstIndex++) {
+        int srcIndex = sortedIndices.get(dstIndex);
+
+        dstVector.copyFromSafe(srcIndex, dstIndex, srcVector);
+      }
+    }
+  }
+}
diff --git a/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestFixedWidthOutOfPlaceVectorSorter.java b/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestFixedWidthOutOfPlaceVectorSorter.java
index e3701f1d8ee..cc13e7f8cea 100644
--- a/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestFixedWidthOutOfPlaceVectorSorter.java
+++ b/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestFixedWidthOutOfPlaceVectorSorter.java
@@ -24,6 +24,7 @@
 
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.memory.RootAllocator;
+import org.apache.arrow.vector.BaseFixedWidthVector;
 import org.apache.arrow.vector.BigIntVector;
 import org.apache.arrow.vector.Float4Vector;
 import org.apache.arrow.vector.Float8Vector;
@@ -39,10 +40,18 @@
 /**
  * Test cases for {@link FixedWidthOutOfPlaceVectorSorter}.
  */
-public class TestFixedWidthOutOfPlaceVectorSorter {
+public class TestFixedWidthOutOfPlaceVectorSorter extends TestOutOfPlaceVectorSorter {
 
   private BufferAllocator allocator;
 
+  public TestFixedWidthOutOfPlaceVectorSorter(boolean generalSorter) {
+    super(generalSorter);
+  }
+
+  <V extends BaseFixedWidthVector> OutOfPlaceVectorSorter<V> getSorter() {
+    return generalSorter ? new GeneralOutOfPlaceVectorSorter<>() : new FixedWidthOutOfPlaceVectorSorter<>();
+  }
+
   @Before
   public void prepare() {
     allocator = new RootAllocator(1024 * 1024);
@@ -72,7 +81,7 @@ public void testSortByte() {
       vec.set(9, 2);
 
       // sort the vector
-      FixedWidthOutOfPlaceVectorSorter sorter = new FixedWidthOutOfPlaceVectorSorter();
+      OutOfPlaceVectorSorter<TinyIntVector> sorter = getSorter();
       VectorValueComparator<TinyIntVector> comparator = DefaultVectorComparators.createDefaultComparator(vec);
 
       TinyIntVector sortedVec =
@@ -119,7 +128,7 @@ public void testSortShort() {
       vec.set(9, 2);
 
       // sort the vector
-      FixedWidthOutOfPlaceVectorSorter sorter = new FixedWidthOutOfPlaceVectorSorter();
+      OutOfPlaceVectorSorter<SmallIntVector> sorter = getSorter();
       VectorValueComparator<SmallIntVector> comparator = DefaultVectorComparators.createDefaultComparator(vec);
 
       SmallIntVector sortedVec =
@@ -166,7 +175,7 @@ public void testSortInt() {
       vec.set(9, 2);
 
       // sort the vector
-      FixedWidthOutOfPlaceVectorSorter sorter = new FixedWidthOutOfPlaceVectorSorter();
+      OutOfPlaceVectorSorter<IntVector> sorter = getSorter();
       VectorValueComparator<IntVector> comparator = DefaultVectorComparators.createDefaultComparator(vec);
 
       IntVector sortedVec = (IntVector) vec.getField().getFieldType().createNewSingleVector("", allocator, null);
@@ -212,7 +221,7 @@ public void testSortLong() {
       vec.set(9, 2L);
 
       // sort the vector
-      FixedWidthOutOfPlaceVectorSorter sorter = new FixedWidthOutOfPlaceVectorSorter();
+      OutOfPlaceVectorSorter<BigIntVector> sorter = getSorter();
       VectorValueComparator<BigIntVector> comparator = DefaultVectorComparators.createDefaultComparator(vec);
 
       BigIntVector sortedVec = (BigIntVector) vec.getField().getFieldType().createNewSingleVector("", allocator, null);
@@ -258,7 +267,7 @@ public void testSortFloat() {
       vec.set(9, 2f);
 
       // sort the vector
-      FixedWidthOutOfPlaceVectorSorter sorter = new FixedWidthOutOfPlaceVectorSorter();
+      OutOfPlaceVectorSorter<Float4Vector> sorter = getSorter();
       VectorValueComparator<Float4Vector> comparator = DefaultVectorComparators.createDefaultComparator(vec);
 
       Float4Vector sortedVec = (Float4Vector) vec.getField().getFieldType().createNewSingleVector("", allocator, null);
@@ -304,7 +313,7 @@ public void testSortDouble() {
       vec.set(9, 2);
 
       // sort the vector
-      FixedWidthOutOfPlaceVectorSorter sorter = new FixedWidthOutOfPlaceVectorSorter();
+      OutOfPlaceVectorSorter<Float8Vector> sorter = getSorter();
       VectorValueComparator<Float8Vector> comparator = DefaultVectorComparators.createDefaultComparator(vec);
 
       Float8Vector sortedVec = (Float8Vector) vec.getField().getFieldType().createNewSingleVector("", allocator, null);
@@ -341,7 +350,7 @@ public void testSortInt2() {
           66, 67, 68, 69, 70, 71);
 
       // sort the vector
-      FixedWidthOutOfPlaceVectorSorter sorter = new FixedWidthOutOfPlaceVectorSorter();
+      OutOfPlaceVectorSorter<IntVector> sorter = getSorter();
       VectorValueComparator<IntVector> comparator = DefaultVectorComparators.createDefaultComparator(vec);
 
       try (IntVector sortedVec = (IntVector) vec.getField().getFieldType().createNewSingleVector("", allocator, null)) {
diff --git a/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestGeneralOutOfPlaceVectorSorter.java b/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestGeneralOutOfPlaceVectorSorter.java
new file mode 100644
index 00000000000..07a6b545dda
--- /dev/null
+++ b/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestGeneralOutOfPlaceVectorSorter.java
@@ -0,0 +1,142 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.arrow.algorithm.sort;
+
+import static org.junit.Assert.assertEquals;
+
+import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.memory.RootAllocator;
+import org.apache.arrow.vector.IntVector;
+import org.apache.arrow.vector.complex.StructVector;
+import org.apache.arrow.vector.testing.ValueVectorDataPopulator;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.FieldType;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Test cases for {@link GeneralOutOfPlaceVectorSorter}.
+ */
+public class TestGeneralOutOfPlaceVectorSorter {
+
+  private BufferAllocator allocator;
+
+  @Before
+  public void prepare() {
+    allocator = new RootAllocator(1024 * 1024);
+  }
+
+  @After
+  public void shutdown() {
+    allocator.close();
+  }
+
+  VectorValueComparator<StructVector> getComparator(StructVector structVector) {
+    IntVector child0 = structVector.getChild("column0", IntVector.class);
+    VectorValueComparator<IntVector> childComp0 = DefaultVectorComparators.createDefaultComparator(child0);
+    childComp0.attachVector(child0);
+
+    IntVector child1 = structVector.getChild("column1", IntVector.class);
+    VectorValueComparator<IntVector> childComp1 = DefaultVectorComparators.createDefaultComparator(child1);
+    childComp1.attachVector(child1);
+
+    VectorValueComparator<StructVector> comp = new VectorValueComparator<StructVector>() {
+
+      @Override
+      public int compareNotNull(int index1, int index2) {
+        // compare values by lexicographic order
+        int result0 = childComp0.compare(index1, index2);
+        if (result0 != 0) {
+          return result0;
+        }
+        return childComp1.compare(index1, index2);
+      }
+
+      @Override
+      public VectorValueComparator createNew() {
+        return this;
+      }
+    };
+
+    return comp;
+  }
+
+  @Test
+  public void testSortStructVector() {
+    final int vectorLength = 7;
+    try (StructVector srcVector = StructVector.empty("src struct", allocator);
+         StructVector dstVector = StructVector.empty("dst struct", allocator)) {
+
+      IntVector srcChild0 =
+          srcVector.addOrGet("column0", FieldType.nullable(new ArrowType.Int(32, true)), IntVector.class);
+      IntVector srcChild1 =
+          srcVector.addOrGet("column1", FieldType.nullable(new ArrowType.Int(32, true)), IntVector.class);
+
+      IntVector dstChild0 =
+          dstVector.addOrGet("column0", FieldType.nullable(new ArrowType.Int(32, true)), IntVector.class);
+      IntVector dstChild1 =
+          dstVector.addOrGet("column1", FieldType.nullable(new ArrowType.Int(32, true)), IntVector.class);
+
+      // src struct vector values:
+      // [
+      //   (2, 1)
+      //   (3, 4)
+      //   (5, 4)
+      //   (null, 3)
+      //   (7, null)
+      //   (null, null)
+      //   (6, 6)
+      // ]
+
+      ValueVectorDataPopulator.setVector(srcChild0, 2, 3, 5, null, 7, null, 6);
+      ValueVectorDataPopulator.setVector(srcChild1, 1, 4, 4, 3, null, null, 6);
+      srcVector.setIndexDefined(0);
+      srcVector.setIndexDefined(1);
+      srcVector.setIndexDefined(2);
+      srcVector.setIndexDefined(3);
+      srcVector.setIndexDefined(4);
+      srcVector.setIndexDefined(6);
+      srcVector.setValueCount(vectorLength);
+
+      dstChild0.allocateNew(vectorLength);
+      dstChild1.allocateNew(vectorLength);
+      dstVector.setValueCount(vectorLength);
+
+      // construct the comparator
+      VectorValueComparator<StructVector> comp = getComparator(srcVector);
+
+      // sort the vector
+      GeneralOutOfPlaceVectorSorter<StructVector> sorter = new GeneralOutOfPlaceVectorSorter<>();
+      sorter.sortOutOfPlace(srcVector, dstVector, comp);
+
+      // validate results
+      assertEquals(vectorLength, dstVector.getValueCount());
+      assertEquals(
+          "[" +
+                    "null, " +
+                    "{\"column1\":3}, " +
+                    "{\"column0\":2,\"column1\":1}, " +
+                    "{\"column0\":3,\"column1\":4}, " +
+                    "{\"column0\":5,\"column1\":4}, " +
+                    "{\"column0\":6,\"column1\":6}, " +
+                    "{\"column0\":7}" +
+              "]", dstVector.toString());
+    }
+  }
+}
diff --git a/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestOutOfPlaceVectorSorter.java b/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestOutOfPlaceVectorSorter.java
new file mode 100644
index 00000000000..66b75cbccac
--- /dev/null
+++ b/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestOutOfPlaceVectorSorter.java
@@ -0,0 +1,46 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.arrow.algorithm.sort;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+/**
+ * Test cases for out-of-place sorters.
+ */
+@RunWith(Parameterized.class)
+public abstract class TestOutOfPlaceVectorSorter {
+
+  protected final boolean generalSorter;
+
+  public TestOutOfPlaceVectorSorter(boolean generalSorter) {
+    this.generalSorter = generalSorter;
+  }
+
+  @Parameterized.Parameters(name = "general sorter = {0}")
+  public static Collection<Object[]> getParameter() {
+    List<Object[]> params = new ArrayList<>();
+    params.add(new Object[] {true});
+    params.add(new Object[] {false});
+    return params;
+  }
+}
diff --git a/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestVariableWidthOutOfPlaceVectorSorter.java b/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestVariableWidthOutOfPlaceVectorSorter.java
index 46b30602177..8f4e3b8e194 100644
--- a/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestVariableWidthOutOfPlaceVectorSorter.java
+++ b/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestVariableWidthOutOfPlaceVectorSorter.java
@@ -32,10 +32,19 @@
 /**
  * Test cases for {@link VariableWidthOutOfPlaceVectorSorter}.
  */
-public class TestVariableWidthOutOfPlaceVectorSorter {
+public class TestVariableWidthOutOfPlaceVectorSorter extends TestOutOfPlaceVectorSorter {
 
   private BufferAllocator allocator;
 
+  public TestVariableWidthOutOfPlaceVectorSorter(boolean generalSorter) {
+    super(generalSorter);
+  }
+
+  <V extends BaseVariableWidthVector> OutOfPlaceVectorSorter<V> getSorter() {
+    return generalSorter ? new GeneralOutOfPlaceVectorSorter<>() : new VariableWidthOutOfPlaceVectorSorter<V>();
+  }
+
+
   @Before
   public void prepare() {
     allocator = new RootAllocator(1024 * 1024);
@@ -65,7 +74,7 @@ public void testSortString() {
       vec.set(9, "yes".getBytes());
 
       // sort the vector
-      VariableWidthOutOfPlaceVectorSorter sorter = new VariableWidthOutOfPlaceVectorSorter();
+      OutOfPlaceVectorSorter<BaseVariableWidthVector> sorter = getSorter();
       VectorValueComparator<BaseVariableWidthVector> comparator =
               DefaultVectorComparators.createDefaultComparator(vec);
 
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index d315cc40a2d..248ee78acbd 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -967,6 +967,16 @@ class MakeStructOptions(_MakeStructOptions):
         self._set_options(field_names, field_nullability, field_metadata)
 
 
+cdef class _StructFieldOptions(FunctionOptions):
+    def _set_options(self, indices):
+        self.wrapped.reset(new CStructFieldOptions(indices))
+
+
+class StructFieldOptions(_StructFieldOptions):
+    def __init__(self, indices):
+        self._set_options(indices)
+
+
 cdef class _ScalarAggregateOptions(FunctionOptions):
     def _set_options(self, skip_nulls, min_count):
         self.wrapped.reset(new CScalarAggregateOptions(skip_nulls, min_count))
@@ -1296,6 +1306,29 @@ class TDigestOptions(_TDigestOptions):
         self._set_options(q, delta, buffer_size, skip_nulls, min_count)
 
 
+cdef class _Utf8NormalizeOptions(FunctionOptions):
+    _form_map = {
+        "NFC": CUtf8NormalizeForm_NFC,
+        "NFKC": CUtf8NormalizeForm_NFKC,
+        "NFD": CUtf8NormalizeForm_NFD,
+        "NFKD": CUtf8NormalizeForm_NFKD,
+    }
+
+    def _set_options(self, form):
+        try:
+            self.wrapped.reset(
+                new CUtf8NormalizeOptions(self._form_map[form])
+            )
+        except KeyError:
+            _raise_invalid_function_option(form,
+                                           "Unicode normalization form")
+
+
+class Utf8NormalizeOptions(_Utf8NormalizeOptions):
+    def __init__(self, form):
+        self._set_options(form)
+
+
 def _group_by(args, keys, aggregations):
     cdef:
         vector[CDatum] c_args
diff --git a/python/pyarrow/compute.py b/python/pyarrow/compute.py
index 7192f49336b..9dac606c3fc 100644
--- a/python/pyarrow/compute.py
+++ b/python/pyarrow/compute.py
@@ -60,9 +60,11 @@
     SplitPatternOptions,
     StrftimeOptions,
     StrptimeOptions,
+    StructFieldOptions,
     TakeOptions,
     TDigestOptions,
     TrimOptions,
+    Utf8NormalizeOptions,
     VarianceOptions,
     WeekOptions,
     # Functions
@@ -187,7 +189,7 @@ def wrapper(*args, memory_pool=None):
             if arity is not Ellipsis and len(args) != arity:
                 raise TypeError(
                     f"{func_name} takes {arity} positional argument(s), "
-                    "but {len(args)} were given"
+                    f"but {len(args)} were given"
                 )
             return func.call(args, None, memory_pool)
     else:
@@ -195,7 +197,7 @@ def wrapper(*args, memory_pool=None, options=None, **kwargs):
             if arity is not Ellipsis and len(args) != arity:
                 raise TypeError(
                     f"{func_name} takes {arity} positional argument(s), "
-                    "but {len(args)} were given"
+                    f"but {len(args)} were given"
                 )
             options = _handle_options(func_name, option_class, options,
                                       kwargs)
diff --git a/python/pyarrow/dataset.py b/python/pyarrow/dataset.py
index 42515a9f4bd..887fba52bf9 100644
--- a/python/pyarrow/dataset.py
+++ b/python/pyarrow/dataset.py
@@ -568,8 +568,8 @@ def dataset(source, schema=None, format=None, filesystem=None,
         Optionally provide the Schema for the Dataset, in which case it will
         not be inferred from the source.
     format : FileFormat or str
-        Currently "parquet" and "ipc"/"arrow"/"feather" are supported. For
-        Feather, only version 2 files are supported.
+        Currently "parquet", "ipc"/"arrow"/"feather", "csv", and "orc" are
+        supported. For Feather, only version 2 files are supported.
     filesystem : FileSystem or URI string, default None
         If a single path is given as source and filesystem is None, then the
         filesystem will be inferred from the path.
@@ -757,10 +757,10 @@ def write_dataset(data, base_dir, basename_template=None, format=None,
         "part-{i}." + format.default_extname
     format : FileFormat or str
         The format in which to write the dataset. Currently supported:
-        "parquet", "ipc"/"feather". If a FileSystemDataset is being written
-        and `format` is not specified, it defaults to the same format as the
-        specified FileSystemDataset. When writing a Table or RecordBatch, this
-        keyword is required.
+        "parquet", "ipc"/"arrow"/"feather", and "csv". If a FileSystemDataset
+        is being written and `format` is not specified, it defaults to the
+        same format as the specified FileSystemDataset. When writing a
+        Table or RecordBatch, this keyword is required.
     partitioning : Partitioning or list[str], optional
         The partitioning scheme specified with the ``partitioning()``
         function or a list of field names. When providing a list of
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index d7706df2899..ef3b6c2fa0a 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -2097,6 +2097,11 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
         vector[c_bool] field_nullability
         vector[shared_ptr[const CKeyValueMetadata]] field_metadata
 
+    cdef cppclass CStructFieldOptions \
+            "arrow::compute::StructFieldOptions"(CFunctionOptions):
+        CStructFieldOptions(vector[int] indices)
+        vector[int] indices
+
     ctypedef enum CSortOrder" arrow::compute::SortOrder":
         CSortOrder_Ascending \
             "arrow::compute::SortOrder::Ascending"
@@ -2166,6 +2171,18 @@ cdef extern from "arrow/compute/api.h" namespace "arrow::compute" nogil:
         c_bool skip_nulls
         uint32_t min_count
 
+    cdef enum CUtf8NormalizeForm \
+            "arrow::compute::Utf8NormalizeOptions::Form":
+        CUtf8NormalizeForm_NFC "arrow::compute::Utf8NormalizeOptions::NFC"
+        CUtf8NormalizeForm_NFKC "arrow::compute::Utf8NormalizeOptions::NFKC"
+        CUtf8NormalizeForm_NFD "arrow::compute::Utf8NormalizeOptions::NFD"
+        CUtf8NormalizeForm_NFKD "arrow::compute::Utf8NormalizeOptions::NFKD"
+
+    cdef cppclass CUtf8NormalizeOptions \
+            "arrow::compute::Utf8NormalizeOptions"(CFunctionOptions):
+        CUtf8NormalizeOptions(CUtf8NormalizeForm form)
+        CUtf8NormalizeForm form
+
     cdef enum DatumType" arrow::Datum::type":
         DatumType_NONE" arrow::Datum::NONE"
         DatumType_SCALAR" arrow::Datum::SCALAR"
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index e84d50ad65a..9110a3a53a8 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -152,9 +152,11 @@ def test_option_class_equality():
         pc.SplitPatternOptions("pattern"),
         pc.StrftimeOptions(),
         pc.StrptimeOptions("%Y", "s"),
+        pc.StructFieldOptions(indices=[]),
         pc.TakeOptions(),
         pc.TDigestOptions(),
         pc.TrimOptions(" "),
+        pc.Utf8NormalizeOptions("NFKC"),
         pc.VarianceOptions(),
         pc.WeekOptions(week_starts_monday=True, count_from_zero=False,
                        first_week_is_fully_in_year=False),
@@ -2208,6 +2210,25 @@ def test_make_struct():
         pc.make_struct(field_names=['one', 'two'])
 
 
+def test_struct_fields_options():
+    a = pa.array([4, 5, 6], type=pa.int64())
+    b = pa.array(["bar", None, ""])
+    c = pa.StructArray.from_arrays([a, b], ["a", "b"])
+    arr = pa.StructArray.from_arrays([a, c], ["a", "c"])
+
+    assert pc.struct_field(arr,
+                           indices=[1, 1]) == pa.array(["bar", None, ""])
+    assert pc.struct_field(arr,
+                           indices=[0]) == pa.array([4, 5, 6], type=pa.int64())
+    assert pc.struct_field(arr, indices=[]) == arr
+
+    with pytest.raises(TypeError, match="an integer is required"):
+        pc.struct_field(arr, indices=['a'])
+
+    # TODO: https://issues.apache.org/jira/browse/ARROW-14853
+    # assert pc.struct_field(arr) == arr
+
+
 def test_case_when():
     assert pc.case_when(pc.make_struct([True, False, None],
                                        [False, True, None]),
@@ -2248,3 +2269,13 @@ def test_count_distinct_options():
     assert pc.count_distinct(arr, mode='only_valid').as_py() == 3
     assert pc.count_distinct(arr, mode='only_null').as_py() == 1
     assert pc.count_distinct(arr, mode='all').as_py() == 4
+
+
+def test_utf8_normalize():
+    arr = pa.array(["01²3"])
+    assert pc.utf8_normalize(arr, form="NFC") == arr
+    assert pc.utf8_normalize(arr, form="NFKC") == pa.array(["0123"])
+    with pytest.raises(
+            ValueError,
+            match='"NFZ" is not a valid Unicode normalization form'):
+        pc.utf8_normalize(arr, form="NFZ")
diff --git a/r/NAMESPACE b/r/NAMESPACE
index 31fd9cf6a87..c8aae1b9346 100644
--- a/r/NAMESPACE
+++ b/r/NAMESPACE
@@ -214,6 +214,8 @@ export(dataset_factory)
 export(date32)
 export(date64)
 export(decimal)
+export(decimal128)
+export(decimal256)
 export(default_memory_pool)
 export(dictionary)
 export(ends_with)
diff --git a/r/NEWS.md b/r/NEWS.md
index 7666b49c7a7..96f3fcc9e8f 100644
--- a/r/NEWS.md
+++ b/r/NEWS.md
@@ -19,6 +19,9 @@
 
 # arrow 6.0.1.9000
 
+* Added `decimal256()`.
+* Added `decimal128()` (identical to `decimal()`) as the name is more explicit and updated docs to encourage its use. 
+
 # arrow 6.0.1
 
 * Joins now support inclusion of dictionary columns, and multiple crashes have been fixed
diff --git a/r/R/arrowExports.R b/r/R/arrowExports.R
index c1e0fca788d..5eaf1b91c5b 100644
--- a/r/R/arrowExports.R
+++ b/r/R/arrowExports.R
@@ -696,6 +696,10 @@ Decimal128Type__initialize <- function(precision, scale) {
   .Call(`_arrow_Decimal128Type__initialize`, precision, scale)
 }
 
+Decimal256Type__initialize <- function(precision, scale) {
+  .Call(`_arrow_Decimal256Type__initialize`, precision, scale)
+}
+
 FixedSizeBinary__initialize <- function(byte_width) {
   .Call(`_arrow_FixedSizeBinary__initialize`, byte_width)
 }
diff --git a/r/R/dplyr-functions.R b/r/R/dplyr-functions.R
index b1f8a65f93d..ccd7ded3cca 100644
--- a/r/R/dplyr-functions.R
+++ b/r/R/dplyr-functions.R
@@ -201,7 +201,7 @@ nse_funcs$is.numeric <- function(x) {
   is.numeric(x) || (inherits(x, "Expression") && x$type_id() %in% Type[c(
     "UINT8", "INT8", "UINT16", "INT16", "UINT32", "INT32",
     "UINT64", "INT64", "HALF_FLOAT", "FLOAT", "DOUBLE",
-    "DECIMAL", "DECIMAL256"
+    "DECIMAL128", "DECIMAL256"
   )])
 }
 nse_funcs$is.double <- function(x) {
@@ -250,6 +250,60 @@ nse_funcs$is_logical <- function(x, n = NULL) {
   nse_funcs$is.logical(x)
 }
 
+# Create a data frame/tibble/struct column
+nse_funcs$tibble <- function(..., .rows = NULL, .name_repair = NULL) {
+  if (!is.null(.rows)) arrow_not_supported(".rows")
+  if (!is.null(.name_repair)) arrow_not_supported(".name_repair")
+
+  # use dots_list() because this is what tibble() uses to allow the
+  # useful shorthand of tibble(col1, col2) -> tibble(col1 = col1, col2 = col2)
+  # we have a stronger enforcement of unique names for arguments because
+  # it is difficult to replicate the .name_repair semantics and expanding of
+  # unnamed data frame arguments in the same way that the tibble() constructor
+  # does.
+  args <- rlang::dots_list(..., .named = TRUE, .homonyms = "error")
+
+  build_expr(
+    "make_struct",
+    args = unname(args),
+    options = list(field_names = names(args))
+  )
+}
+
+nse_funcs$data.frame <- function(..., row.names = NULL,
+                                 check.rows = NULL, check.names = TRUE, fix.empty.names = TRUE,
+                                 stringsAsFactors = FALSE) {
+  # we need a specific value of stringsAsFactors because the default was
+  # TRUE in R <= 3.6
+  if (!identical(stringsAsFactors, FALSE)) {
+    arrow_not_supported("stringsAsFactors = TRUE")
+  }
+
+  # ignore row.names and check.rows with a warning
+  if (!is.null(row.names)) arrow_not_supported("row.names")
+  if (!is.null(check.rows)) arrow_not_supported("check.rows")
+
+  args <- rlang::dots_list(..., .named = fix.empty.names)
+  if (is.null(names(args))) {
+    names(args) <- rep("", length(args))
+  }
+
+  if (identical(check.names, TRUE)) {
+    if (identical(fix.empty.names, TRUE)) {
+      names(args) <- make.names(names(args), unique = TRUE)
+    } else {
+      name_emtpy <- names(args) == ""
+      names(args)[!name_emtpy] <- make.names(names(args)[!name_emtpy], unique = TRUE)
+    }
+  }
+
+  build_expr(
+    "make_struct",
+    args = unname(args),
+    options = list(field_names = names(args))
+  )
+}
+
 # String functions
 nse_funcs$nchar <- function(x, type = "chars", allowNA = FALSE, keepNA = NA) {
   if (allowNA) {
diff --git a/r/R/dplyr-summarize.R b/r/R/dplyr-summarize.R
index e68f74f2410..3b7d51ed47e 100644
--- a/r/R/dplyr-summarize.R
+++ b/r/R/dplyr-summarize.R
@@ -166,14 +166,37 @@ format_aggregation <- function(x) {
 # appropriate combination of (1) aggregations (possibly temporary) and
 # (2) post-aggregation transformations (mutate)
 # The function returns nothing: it assigns into the `ctx` environment
-summarize_eval <- function(name, quosure, ctx, hash, recurse = FALSE) {
+summarize_eval <- function(name, quosure, ctx, hash) {
   expr <- quo_get_expr(quosure)
   ctx$quo_env <- quo_get_env(quosure)
 
   funs_in_expr <- all_funs(expr)
+
   if (length(funs_in_expr) == 0) {
-    # If it is a scalar or field ref, no special handling required
-    ctx$aggregations[[name]] <- arrow_eval_or_stop(quosure, ctx$mask)
+    # This branch only gets called at the top level, where expr is something
+    # that is not a function call (could be a quosure, a symbol, or atomic
+    # value). This needs to evaluate to a scalar or something that can be
+    # converted to one.
+    value <- arrow_eval_or_stop(quosure, ctx$mask)
+
+    if (!inherits(value, "Expression")) {
+      value <- Expression$scalar(value)
+    }
+
+    # We can't support a bare field reference because this is not
+    # an aggregate expression
+    if (!identical(value$field_name, "")) {
+      abort(
+        paste(
+          "Expression", format_expr(quosure),
+          "is not an aggregate expression or is not supported in Arrow"
+        )
+      )
+    }
+
+    # Scalars need to be added to post_mutate because they don't need
+    # to be sent to the query engine as an aggregation
+    ctx$post_mutate[[name]] <- value
     return()
   }
 
@@ -229,18 +252,27 @@ summarize_eval <- function(name, quosure, ctx, hash, recurse = FALSE) {
         )
       )
     )
-    ctx$post_mutate[[name]] <- arrow_eval_or_stop(
+
+    value <- arrow_eval_or_stop(
       as_quosure(expr, ctx$quo_env),
       mutate_mask
     )
+
+    if (!inherits(value, "Expression")) {
+      value <- Expression$scalar(value)
+    }
+
+    ctx$post_mutate[[name]] <- value
     return()
   }
 
   # Backstop for any other odd cases, like fun(x, y) (i.e. no aggregation),
   # or aggregation functions that aren't supported in Arrow (not in agg_funcs)
-  stop(
-    handle_arrow_not_supported(quo_get_expr(quosure), format_expr(quosure)),
-    call. = FALSE
+  abort(
+    paste(
+      "Expression", format_expr(quosure),
+      "is not an aggregate expression or is not supported in Arrow"
+    )
   )
 }
 
@@ -258,16 +290,16 @@ extract_aggregations <- function(expr, ctx) {
   }
   if (funs[1] %in% names(agg_funcs)) {
     inner_agg_exprs <- all_vars(expr) %in% names(ctx$aggregations)
-    if (any(inner_agg_exprs) & !all(inner_agg_exprs)) {
+    if (any(inner_agg_exprs)) {
       # We can't aggregate over a combination of dataset columns and other
       # aggregations (e.g. sum(x - mean(x)))
       # TODO: support in ARROW-13926
-      # TODO: Add "because" arg to explain _why_ it's not supported?
-      # TODO: this message could also say "not supported in summarize()"
-      #       since some of these expressions may be legal elsewhere
-      stop(
-        handle_arrow_not_supported(original_expr, format_expr(original_expr)),
-        call. = FALSE
+      abort(
+        paste(
+          "Aggregate within aggregate expression",
+          format_expr(original_expr),
+          "not supported in Arrow"
+        )
       )
     }
 
diff --git a/r/R/duckdb.R b/r/R/duckdb.R
index c29fafe244b..960892fbf88 100644
--- a/r/R/duckdb.R
+++ b/r/R/duckdb.R
@@ -59,7 +59,7 @@ to_duckdb <- function(.data,
   .data <- as_adq(.data)
   duckdb::duckdb_register_arrow(con, table_name, .data)
 
-  tbl <- tbl(con, table_name)
+  tbl <- dplyr::tbl(con, table_name)
   groups <- dplyr::groups(.data)
   if (length(groups)) {
     tbl <- dplyr::group_by(tbl, groups)
diff --git a/r/R/enums.R b/r/R/enums.R
index 4e69b7a190e..17d0484b997 100644
--- a/r/R/enums.R
+++ b/r/R/enums.R
@@ -65,7 +65,7 @@ Type <- enum("Type::type",
   TIME64 = 20L,
   INTERVAL_MONTHS = 21L,
   INTERVAL_DAY_TIME = 22L,
-  DECIMAL = 23L,
+  DECIMAL128 = 23L,
   DECIMAL256 = 24L,
   LIST = 25L,
   STRUCT = 26L,
diff --git a/r/R/type.R b/r/R/type.R
index ac3dcf3e95f..6a021bbebd2 100644
--- a/r/R/type.R
+++ b/r/R/type.R
@@ -152,6 +152,8 @@ DecimalType <- R6Class("DecimalType",
 )
 Decimal128Type <- R6Class("Decimal128Type", inherit = DecimalType)
 
+Decimal256Type <- R6Class("Decimal256Type", inherit = DecimalType)
+
 NestedType <- R6Class("NestedType", inherit = DataType)
 
 #' Apache Arrow data types
@@ -181,33 +183,37 @@ NestedType <- R6Class("NestedType", inherit = DataType)
 #' `bit64::integer64` object) by setting `options(arrow.int64_downcast =
 #' FALSE)`.
 #'
-#' `decimal()` creates a `decimal128` type. Arrow decimals are fixed-point
+#' `decimal128()` creates a `decimal128` type. Arrow decimals are fixed-point
 #' decimal numbers encoded as a scalar integer. The `precision` is the number of
 #' significant digits that the decimal type can represent; the `scale` is the
 #' number of digits after the decimal point. For example, the number 1234.567
 #' has a precision of 7 and a scale of 3. Note that `scale` can be negative.
 #'
-#' As an example, `decimal(7, 3)` can exactly represent the numbers 1234.567 and
+#' As an example, `decimal128(7, 3)` can exactly represent the numbers 1234.567 and
 #' -1234.567 (encoded internally as the 128-bit integers 1234567 and -1234567,
 #' respectively), but neither 12345.67 nor 123.4567.
 #'
-#' `decimal(5, -3)` can exactly represent the number 12345000 (encoded
+#' `decimal128(5, -3)` can exactly represent the number 12345000 (encoded
 #' internally as the 128-bit integer 12345), but neither 123450000 nor 1234500.
 #' The `scale` can be thought of as an argument that controls rounding. When
 #' negative, `scale` causes the number to be expressed using scientific notation
 #' and power of 10.
 #'
+#' `decimal()` is identical to `decimal128()`, defined for backward compatibility.
+#' Use `decimal128()` as the name  is more informative and `decimal()` might be
+#' deprecated in the future.
+#'
 #' @param unit For time/timestamp types, the time unit. `time32()` can take
 #' either "s" or "ms", while `time64()` can be "us" or "ns". `timestamp()` can
 #' take any of those four values.
 #' @param timezone For `timestamp()`, an optional time zone string.
 #' @param byte_width byte width for `FixedSizeBinary` type.
 #' @param list_size list size for `FixedSizeList` type.
-#' @param precision For `decimal()`, the number of significant digits
-#'    the arrow `decimal` type can represent. The maximum precision for
-#'    `decimal()` is 38 significant digits.
-#' @param scale For `decimal()`, the number of digits after the decimal
-#'    point. It can be negative.
+#' @param precision For `decimal()`, `decimal128()` the number of significant
+#'    digits the arrow `decimal` type can represent. The maximum precision for
+#'    `decimal()` and `decimal128()` is 38 significant digits.
+#' @param scale For `decimal()` and `decimal128()`, the number of digits after
+#'    the decimal point. It can be negative.
 #' @param type For `list_of()`, a data type to make a list-of-type
 #' @param ... For `struct()`, a named list of types to define the struct columns
 #'
@@ -373,7 +379,7 @@ timestamp <- function(unit = c("s", "ms", "us", "ns"), timezone = "") {
 
 #' @rdname data-type
 #' @export
-decimal <- function(precision, scale) {
+decimal128 <- function(precision, scale) {
   if (is.numeric(precision)) {
     precision <- as.integer(precision)
   } else {
@@ -387,6 +393,27 @@ decimal <- function(precision, scale) {
   Decimal128Type__initialize(precision, scale)
 }
 
+#' @rdname data-type
+#' @export
+
+decimal256 <- function(precision, scale) {
+  if (is.numeric(precision)) {
+    precision <- as.integer(precision)
+  } else {
+    stop('"precision" must be an integer', call. = FALSE)
+  }
+  if (is.numeric(scale)) {
+    scale <- as.integer(scale)
+  } else {
+    stop('"scale" must be an integer', call. = FALSE)
+  }
+  Decimal256Type__initialize(precision, scale)
+}
+
+#' @rdname data-type
+#' @export
+decimal <- decimal128
+
 StructType <- R6Class("StructType",
   inherit = NestedType,
   public = list(
@@ -487,7 +514,8 @@ canonical_type_str <- function(type_str) {
     time64 = "time64",
     null = "null",
     timestamp = "timestamp",
-    decimal = "decimal128",
+    decimal128 = "decimal128",
+    decimal256 = "decimal256",
     struct = "struct",
     list_of = "list",
     list = "list",
diff --git a/r/lint.sh b/r/lint.sh
index 629879e0489..91435e7e01a 100755
--- a/r/lint.sh
+++ b/r/lint.sh
@@ -26,7 +26,16 @@ SOURCE_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 CPP_BUILD_SUPPORT=$SOURCE_DIR/../cpp/build-support
 
 # Run clang-format
-: ${CLANG_FORMAT:=$(. "${SOURCE_DIR}/../.env" && echo clang-format-${CLANG_TOOLS})}
+if [ -z "${CLANG_FORMAT:-}" ]; then
+  CLANG_TOOLS=$(. "${SOURCE_DIR}/../.env" && echo ${CLANG_TOOLS})
+  if type clang-format-${CLANG_TOOLS} >/dev/null 2>&1; then
+    CLANG_FORMAT=clang-format-${CLANG_TOOLS}
+  elif type brew >/dev/null 2>&1; then
+    CLANG_FORMAT=$(brew --prefix llvm@${CLANG_TOOLS})/bin/clang-format
+  else
+    CLANG_FORMAT=clang-format
+  fi
+fi
 $CPP_BUILD_SUPPORT/run_clang_format.py \
     --clang_format_binary=$CLANG_FORMAT \
     --exclude_glob=$CPP_BUILD_SUPPORT/lint_exclusions.txt \
diff --git a/r/man/data-type.Rd b/r/man/data-type.Rd
index 2b2313571b2..1caae9e4962 100644
--- a/r/man/data-type.Rd
+++ b/r/man/data-type.Rd
@@ -29,6 +29,8 @@
 \alias{time64}
 \alias{null}
 \alias{timestamp}
+\alias{decimal128}
+\alias{decimal256}
 \alias{decimal}
 \alias{struct}
 \alias{list_of}
@@ -91,6 +93,10 @@ null()
 
 timestamp(unit = c("s", "ms", "us", "ns"), timezone = "")
 
+decimal128(precision, scale)
+
+decimal256(precision, scale)
+
 decimal(precision, scale)
 
 struct(...)
@@ -110,12 +116,12 @@ take any of those four values.}
 
 \item{timezone}{For \code{timestamp()}, an optional time zone string.}
 
-\item{precision}{For \code{decimal()}, the number of significant digits
-the arrow \code{decimal} type can represent. The maximum precision for
-\code{decimal()} is 38 significant digits.}
+\item{precision}{For \code{decimal()}, \code{decimal128()} the number of significant
+digits the arrow \code{decimal} type can represent. The maximum precision for
+\code{decimal()} and \code{decimal128()} is 38 significant digits.}
 
-\item{scale}{For \code{decimal()}, the number of digits after the decimal
-point. It can be negative.}
+\item{scale}{For \code{decimal()} and \code{decimal128()}, the number of digits after
+the decimal point. It can be negative.}
 
 \item{...}{For \code{struct()}, a named list of types to define the struct columns}
 
@@ -153,21 +159,25 @@ are translated to R objects, \code{uint32} and \code{uint64} are converted to \c
 types, this conversion can be disabled (so that \code{int64} always yields a
 \code{bit64::integer64} object) by setting \code{options(arrow.int64_downcast = FALSE)}.
 
-\code{decimal()} creates a \code{decimal128} type. Arrow decimals are fixed-point
+\code{decimal128()} creates a \code{decimal128} type. Arrow decimals are fixed-point
 decimal numbers encoded as a scalar integer. The \code{precision} is the number of
 significant digits that the decimal type can represent; the \code{scale} is the
 number of digits after the decimal point. For example, the number 1234.567
 has a precision of 7 and a scale of 3. Note that \code{scale} can be negative.
 
-As an example, \code{decimal(7, 3)} can exactly represent the numbers 1234.567 and
+As an example, \code{decimal128(7, 3)} can exactly represent the numbers 1234.567 and
 -1234.567 (encoded internally as the 128-bit integers 1234567 and -1234567,
 respectively), but neither 12345.67 nor 123.4567.
 
-\code{decimal(5, -3)} can exactly represent the number 12345000 (encoded
+\code{decimal128(5, -3)} can exactly represent the number 12345000 (encoded
 internally as the 128-bit integer 12345), but neither 123450000 nor 1234500.
 The \code{scale} can be thought of as an argument that controls rounding. When
 negative, \code{scale} causes the number to be expressed using scientific notation
 and power of 10.
+
+\code{decimal()} is identical to \code{decimal128()}, defined for backward compatibility.
+Use \code{decimal128()} as the name  is more informative and \code{decimal()} might be
+deprecated in the future.
 }
 \examples{
 \dontshow{if (arrow_available()) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
diff --git a/r/src/.clang-format b/r/src/.clang-format
index 06453dfbb25..9448dc8d8c8 100644
--- a/r/src/.clang-format
+++ b/r/src/.clang-format
@@ -15,6 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 ---
-BasedOnStyle:  Google
-DerivePointerAlignment: false
+BasedOnStyle: Google
 ColumnLimit: 90
+DerivePointerAlignment: false
+IncludeBlocks: Preserve
diff --git a/r/src/array_to_vector.cpp b/r/src/array_to_vector.cpp
index 49f6d987f85..cf32bffbc1a 100644
--- a/r/src/array_to_vector.cpp
+++ b/r/src/array_to_vector.cpp
@@ -905,6 +905,7 @@ class Converter_Timestamp : public Converter_Time<value_type, TimestampType> {
   }
 };
 
+template <typename Type>
 class Converter_Decimal : public Converter {
  public:
   explicit Converter_Decimal(const std::shared_ptr<ChunkedArray>& chunked_array)
@@ -919,8 +920,9 @@ class Converter_Decimal : public Converter {
 
   Status Ingest_some_nulls(SEXP data, const std::shared_ptr<arrow::Array>& array,
                            R_xlen_t start, R_xlen_t n, size_t chunk_index) const {
+    using DecimalArray = typename TypeTraits<Type>::ArrayType;
     auto p_data = REAL(data) + start;
-    const auto& decimals_arr = checked_cast<const arrow::Decimal128Array&>(*array);
+    const auto& decimals_arr = checked_cast<const arrow::DecimalArray&>(*array);
 
     auto ingest_one = [&](R_xlen_t i) {
       p_data[i] = std::stod(decimals_arr.FormatValue(i).c_str());
@@ -1216,8 +1218,11 @@ std::shared_ptr<Converter> Converter::Make(
         return std::make_shared<arrow::r::Converter_Int64>(chunked_array);
       }
 
-    case Type::DECIMAL:
-      return std::make_shared<arrow::r::Converter_Decimal>(chunked_array);
+    case Type::DECIMAL128:
+      return std::make_shared<arrow::r::Converter_Decimal<Decimal128Type>>(chunked_array);
+
+    case Type::DECIMAL256:
+      return std::make_shared<arrow::r::Converter_Decimal<Decimal256Type>>(chunked_array);
 
       // nested
     case Type::STRUCT:
@@ -1245,7 +1250,7 @@ std::shared_ptr<Converter> Converter::Make(
       break;
   }
 
-  cpp11::stop("cannot handle Array of type ", type->name().c_str());
+  cpp11::stop("cannot handle Array of type <%s>", type->name().c_str());
 }
 
 std::shared_ptr<ChunkedArray> to_chunks(const std::shared_ptr<Array>& array) {
diff --git a/r/src/arrowExports.cpp b/r/src/arrowExports.cpp
index ef388b09208..95e7d458929 100644
--- a/r/src/arrowExports.cpp
+++ b/r/src/arrowExports.cpp
@@ -2730,6 +2730,22 @@ extern "C" SEXP _arrow_Decimal128Type__initialize(SEXP precision_sexp, SEXP scal
 }
 #endif
 
+// datatype.cpp
+#if defined(ARROW_R_WITH_ARROW)
+std::shared_ptr<arrow::DataType> Decimal256Type__initialize(int32_t precision, int32_t scale);
+extern "C" SEXP _arrow_Decimal256Type__initialize(SEXP precision_sexp, SEXP scale_sexp){
+BEGIN_CPP11
+	arrow::r::Input<int32_t>::type precision(precision_sexp);
+	arrow::r::Input<int32_t>::type scale(scale_sexp);
+	return cpp11::as_sexp(Decimal256Type__initialize(precision, scale));
+END_CPP11
+}
+#else
+extern "C" SEXP _arrow_Decimal256Type__initialize(SEXP precision_sexp, SEXP scale_sexp){
+	Rf_error("Cannot call Decimal256Type__initialize(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
+}
+#endif
+
 // datatype.cpp
 #if defined(ARROW_R_WITH_ARROW)
 std::shared_ptr<arrow::DataType> FixedSizeBinary__initialize(R_xlen_t byte_width);
@@ -7345,6 +7361,7 @@ static const R_CallMethodDef CallEntries[] = {
 		{ "_arrow_Date64__initialize", (DL_FUNC) &_arrow_Date64__initialize, 0}, 
 		{ "_arrow_Null__initialize", (DL_FUNC) &_arrow_Null__initialize, 0}, 
 		{ "_arrow_Decimal128Type__initialize", (DL_FUNC) &_arrow_Decimal128Type__initialize, 2}, 
+		{ "_arrow_Decimal256Type__initialize", (DL_FUNC) &_arrow_Decimal256Type__initialize, 2}, 
 		{ "_arrow_FixedSizeBinary__initialize", (DL_FUNC) &_arrow_FixedSizeBinary__initialize, 1}, 
 		{ "_arrow_Timestamp__initialize", (DL_FUNC) &_arrow_Timestamp__initialize, 2}, 
 		{ "_arrow_Time32__initialize", (DL_FUNC) &_arrow_Time32__initialize, 1}, 
diff --git a/r/src/datatype.cpp b/r/src/datatype.cpp
index ffbe1ecc5e0..942b6f0133d 100644
--- a/r/src/datatype.cpp
+++ b/r/src/datatype.cpp
@@ -80,8 +80,10 @@ const char* r6_class_name<arrow::DataType>::get(
     case Type::TIME64:
       return "Time64";
 
-    case Type::DECIMAL:
+    case Type::DECIMAL128:
       return "Decimal128Type";
+    case Type::DECIMAL256:
+      return "Decimal256Type";
 
     case Type::LIST:
       return "ListType";
@@ -180,6 +182,13 @@ std::shared_ptr<arrow::DataType> Decimal128Type__initialize(int32_t precision,
   return ValueOrStop(arrow::Decimal128Type::Make(precision, scale));
 }
 
+// [[arrow::export]]
+std::shared_ptr<arrow::DataType> Decimal256Type__initialize(int32_t precision,
+                                                            int32_t scale) {
+  // Use the builder that validates inputs
+  return ValueOrStop(arrow::Decimal256Type::Make(precision, scale));
+}
+
 // [[arrow::export]]
 std::shared_ptr<arrow::DataType> FixedSizeBinary__initialize(R_xlen_t byte_width) {
   if (byte_width == NA_INTEGER) {
diff --git a/r/src/nameof.h b/r/src/nameof.h
index ae49880b827..912f0d0f298 100644
--- a/r/src/nameof.h
+++ b/r/src/nameof.h
@@ -55,9 +55,9 @@ const size_t typename_prefix = search(raw<double>(), "double");
 template <typename T>
 size_t struct_class_prefix() {
 #ifdef _MSC_VER
-  return starts_with(raw<T>() + typename_prefix, "struct ")
-             ? 7
-             : starts_with(raw<T>() + typename_prefix, "class ") ? 6 : 0;
+  return starts_with(raw<T>() + typename_prefix, "struct ")  ? 7
+         : starts_with(raw<T>() + typename_prefix, "class ") ? 6
+                                                             : 0;
 #else
   return 0;
 #endif
diff --git a/r/src/r_to_arrow.cpp b/r/src/r_to_arrow.cpp
index d4beca96ec7..0a600501c7c 100644
--- a/r/src/r_to_arrow.cpp
+++ b/r/src/r_to_arrow.cpp
@@ -1119,7 +1119,7 @@ std::shared_ptr<Array> MakeSimpleArray(SEXP x) {
   auto first_na = std::find_if(p_vec_start, p_vec_end, is_NA<value_type>);
   if (first_na < p_vec_end) {
     auto null_bitmap =
-        ValueOrStop(AllocateBuffer(BitUtil::BytesForBits(n), gc_memory_pool()));
+        ValueOrStop(AllocateBuffer(bit_util::BytesForBits(n), gc_memory_pool()));
     internal::FirstTimeBitmapWriter bitmap_writer(null_bitmap->mutable_data(), 0, n);
 
     // first loop to clear all the bits before the first NA
@@ -1237,7 +1237,7 @@ bool vector_from_r_memory_impl(SEXP x, const std::shared_ptr<DataType>& type,
 
     if (first_na < p_x_end) {
       auto null_bitmap =
-          ValueOrStop(AllocateBuffer(BitUtil::BytesForBits(n), gc_memory_pool()));
+          ValueOrStop(AllocateBuffer(bit_util::BytesForBits(n), gc_memory_pool()));
       internal::FirstTimeBitmapWriter bitmap_writer(null_bitmap->mutable_data(), 0, n);
 
       // first loop to clear all the bits before the first NA
diff --git a/r/tests/testthat/test-chunked-array.R b/r/tests/testthat/test-chunked-array.R
index c931ddec5a2..95968b5d4e3 100644
--- a/r/tests/testthat/test-chunked-array.R
+++ b/r/tests/testthat/test-chunked-array.R
@@ -206,7 +206,7 @@ test_that("ChunkedArray supports empty arrays (ARROW-13761)", {
     int8(), int16(), int32(), int64(), uint8(), uint16(), uint32(),
     uint64(), float32(), float64(), timestamp("ns"), binary(),
     large_binary(), fixed_size_binary(32), date32(), date64(),
-    decimal(4, 2), dictionary(), struct(x = int32())
+    decimal128(4, 2), decimal256(4, 2), dictionary(), struct(x = int32())
   )
 
   empty_filter <- ChunkedArray$create(type = bool())
diff --git a/r/tests/testthat/test-data-type.R b/r/tests/testthat/test-data-type.R
index 98dc9ebfbda..82a5ff2ff99 100644
--- a/r/tests/testthat/test-data-type.R
+++ b/r/tests/testthat/test-data-type.R
@@ -385,16 +385,28 @@ test_that("DictionaryType validation", {
 })
 
 test_that("decimal type and validation", {
-  expect_error(decimal())
+  expect_r6_class(decimal(4, 2), "Decimal128Type")
+
   expect_error(decimal("four"), '"precision" must be an integer')
-  expect_error(decimal(4))
   expect_error(decimal(4, "two"), '"scale" must be an integer')
   expect_error(decimal(NA, 2), '"precision" must be an integer')
-  expect_error(decimal(0, 2), "Invalid: Decimal precision out of range [1, 38]: 0", fixed = TRUE)
-  expect_error(decimal(100, 2), "Invalid: Decimal precision out of range [1, 38]: 100", fixed = TRUE)
   expect_error(decimal(4, NA), '"scale" must be an integer')
 
-  expect_r6_class(decimal(4, 2), "Decimal128Type")
+  # decimal() is just an alias for decimal128() for backwards compatibility
+  expect_r6_class(decimal128(4, 2), "Decimal128Type")
+  expect_identical(class(decimal(2, 4)), class(decimal128(2, 4)))
+
+  expect_error(decimal128("four"), '"precision" must be an integer')
+  expect_error(decimal128(4, "two"), '"scale" must be an integer')
+  expect_error(decimal128(NA, 2), '"precision" must be an integer')
+  expect_error(decimal128(4, NA), '"scale" must be an integer')
+
+  expect_r6_class(decimal256(4, 2), "Decimal256Type")
+
+  expect_error(decimal256("four"), '"precision" must be an integer')
+  expect_error(decimal256(4, "two"), '"scale" must be an integer')
+  expect_error(decimal256(NA, 2), '"precision" must be an integer')
+  expect_error(decimal256(4, NA), '"scale" must be an integer')
 })
 
 test_that("Binary", {
diff --git a/r/tests/testthat/test-dplyr-funcs-type.R b/r/tests/testthat/test-dplyr-funcs-type.R
index 859dc14b99b..22696eb2ae6 100644
--- a/r/tests/testthat/test-dplyr-funcs-type.R
+++ b/r/tests/testthat/test-dplyr-funcs-type.R
@@ -208,33 +208,40 @@ test_that("type checks with is() giving Arrow types", {
     Table$create(
       i32 = Array$create(1, int32()),
       dec = Array$create(pi)$cast(decimal(3, 2)),
+      dec128 = Array$create(pi)$cast(decimal128(3, 2)),
       f64 = Array$create(1.1, float64()),
       str = Array$create("a", arrow::string())
     ) %>% transmute(
       i32_is_i32 = is(i32, int32()),
       i32_is_dec = is(i32, decimal(3, 2)),
+      i32_is_dec128 = is(i32, decimal128(3, 2)),
       i32_is_i64 = is(i32, float64()),
       i32_is_str = is(i32, arrow::string()),
       dec_is_i32 = is(dec, int32()),
       dec_is_dec = is(dec, decimal(3, 2)),
+      dec_is_dec128 = is(dec, decimal128(3, 2)),
       dec_is_i64 = is(dec, float64()),
       dec_is_str = is(dec, arrow::string()),
+      dec128_is_i32 = is(dec128, int32()),
+      dec128_is_dec128 = is(dec128, decimal128(3, 2)),
+      dec128_is_i64 = is(dec128, float64()),
+      dec128_is_str = is(dec128, arrow::string()),
       f64_is_i32 = is(f64, int32()),
       f64_is_dec = is(f64, decimal(3, 2)),
+      f64_is_dec128 = is(f64, decimal128(3, 2)),
       f64_is_i64 = is(f64, float64()),
       f64_is_str = is(f64, arrow::string()),
       str_is_i32 = is(str, int32()),
-      str_is_dec = is(str, decimal(3, 2)),
+      str_is_dec128 = is(str, decimal128(3, 2)),
       str_is_i64 = is(str, float64()),
       str_is_str = is(str, arrow::string())
     ) %>%
       collect() %>%
       t() %>%
       as.vector(),
-    c(
-      TRUE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE,
-      FALSE, FALSE, FALSE, FALSE, TRUE
-    )
+    c(TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE,
+      TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE,
+      TRUE)
   )
   # with class2=string
   expect_equal(
@@ -625,3 +632,128 @@ test_that("bad explicit type conversions with as.*()", {
     )
   )
 })
+
+test_that("structs/nested data frames/tibbles can be created", {
+  df <- tibble(regular_col1 = 1L, regular_col2 = "a")
+
+  compare_dplyr_binding(
+    .input %>%
+      transmute(
+        df_col = tibble(
+          regular_col1 = regular_col1,
+          regular_col2 = regular_col2
+        )
+      ) %>%
+      collect(),
+    df
+  )
+
+  # check auto column naming
+  compare_dplyr_binding(
+    .input %>%
+      transmute(
+        df_col = tibble(regular_col1, regular_col2)
+      ) %>%
+      collect(),
+    df
+  )
+
+  # ...and that other arguments are not supported
+  expect_warning(
+    record_batch(char_col = "a") %>%
+      mutate(df_col = tibble(char_col, .rows = 1L)),
+    ".rows not supported in Arrow"
+  )
+
+  expect_warning(
+    record_batch(char_col = "a") %>%
+      mutate(df_col = tibble(char_col, .name_repair = "universal")),
+    ".name_repair not supported in Arrow"
+  )
+
+  # check that data.frame is mapped too
+  # stringsAsFactors default is TRUE in R 3.6, which is still tested on CI
+  compare_dplyr_binding(
+    .input %>%
+      transmute(
+        df_col = data.frame(regular_col1, regular_col2, stringsAsFactors = FALSE)
+      ) %>%
+      collect() %>%
+      mutate(df_col = as.data.frame(df_col)),
+    df
+  )
+
+  # check with fix.empty.names = FALSE
+  compare_dplyr_binding(
+    .input %>%
+      transmute(
+        df_col = data.frame(regular_col1, fix.empty.names = FALSE)
+      ) %>%
+      collect() %>%
+      mutate(df_col = as.data.frame(df_col)),
+    df
+  )
+
+  # check with check.names = TRUE and FALSE
+  compare_dplyr_binding(
+    .input %>%
+      transmute(
+        df_col = data.frame(regular_col1, regular_col1, check.names = TRUE)
+      ) %>%
+      collect() %>%
+      mutate(df_col = as.data.frame(df_col)),
+    df
+  )
+
+  compare_dplyr_binding(
+    .input %>%
+      transmute(
+        df_col = data.frame(regular_col1, regular_col1, check.names = FALSE)
+      ) %>%
+      collect() %>%
+      mutate(df_col = as.data.frame(df_col)),
+    df
+  )
+
+  # ...and that other arguments are not supported
+  expect_warning(
+    record_batch(char_col = "a") %>%
+      mutate(df_col = data.frame(char_col, stringsAsFactors = TRUE)),
+    "stringsAsFactors = TRUE not supported in Arrow"
+  )
+
+  expect_warning(
+    record_batch(char_col = "a") %>%
+      mutate(df_col = data.frame(char_col, row.names = 1L)),
+    "row.names not supported in Arrow"
+  )
+
+  expect_warning(
+    record_batch(char_col = "a") %>%
+      mutate(df_col = data.frame(char_col, check.rows = TRUE)),
+    "check.rows not supported in Arrow"
+  )
+})
+
+test_that("nested structs can be created from scalars and existing data frames", {
+  compare_dplyr_binding(
+    .input %>%
+      transmute(
+        df_col = tibble(b = 3)
+      ) %>%
+      collect(),
+    tibble(a = 1:2)
+  )
+
+  # technically this is handled by Scalar$create() since there is no
+  # call to data.frame or tibble() within a dplyr verb
+  existing_data_frame <- tibble(b = 3)
+  compare_dplyr_binding(
+    .input %>%
+      transmute(
+        df_col = existing_data_frame
+      ) %>%
+      collect(),
+    tibble(a = 1:2)
+  )
+})
diff --git a/r/tests/testthat/test-dplyr-summarize.R b/r/tests/testthat/test-dplyr-summarize.R
index 2d69524c57f..46a5e98c4c5 100644
--- a/r/tests/testthat/test-dplyr-summarize.R
+++ b/r/tests/testthat/test-dplyr-summarize.R
@@ -705,16 +705,30 @@ test_that("Expressions on aggregations", {
     tbl
   )
 
-  # Aggregate on an aggregate (trivial but dplyr allows)
-  skip("Aggregate on an aggregate not supported")
-  compare_dplyr_binding(
-    .input %>%
-      group_by(some_grouping) %>%
-      summarize(
-        any_lgl = any(any(lgl))
-      ) %>%
-      collect(),
-    tbl
+  # Aggregates on aggregates are not supported
+  expect_warning(
+    record_batch(tbl) %>% summarise(any(any(lgl))),
+    paste(
+      "Aggregate within aggregate expression",
+      "any\\(any\\(lgl\\)\\) not supported in Arrow"
+    )
+  )
+
+  # Check aggregates on aggeregates with more complex calls
+  expect_warning(
+    record_batch(tbl) %>% summarise(any(any(!lgl))),
+    paste(
+      "Aggregate within aggregate expression",
+      "any\\(any\\(!lgl\\)\\) not supported in Arrow"
+    )
+
+  )
+  expect_warning(
+    record_batch(tbl) %>% summarise(!any(any(lgl))),
+    paste(
+      "Aggregate within aggregate expression",
+      "any\\(any\\(lgl\\)\\) not supported in Arrow"
+    )
   )
 })
 
@@ -738,7 +752,10 @@ test_that("Not (yet) supported: implicit join", {
       ) %>%
       collect(),
     tbl,
-    warning = "Expression sum\\(\\(dbl - mean\\(dbl\\)\\)\\^2\\) not supported in Arrow; pulling data into R"
+    warning = paste(
+      "Aggregate within aggregate expression sum\\(\\(dbl - mean\\(dbl\\)\\)\\^2\\)",
+      "not supported in Arrow; pulling data into R"
+    )
   )
   compare_dplyr_binding(
     .input %>%
@@ -748,7 +765,10 @@ test_that("Not (yet) supported: implicit join", {
       ) %>%
       collect(),
     tbl,
-    warning = "Expression sum\\(dbl - mean\\(dbl\\)\\) not supported in Arrow; pulling data into R"
+    warning = paste(
+      "Aggregate within aggregate expression sum\\(dbl - mean\\(dbl\\)\\)",
+      "not supported in Arrow; pulling data into R"
+    )
   )
   compare_dplyr_binding(
     .input %>%
@@ -758,7 +778,10 @@ test_that("Not (yet) supported: implicit join", {
       ) %>%
       collect(),
     tbl,
-    warning = "Expression sum\\(\\(dbl - mean\\(dbl\\)\\)\\^2\\) not supported in Arrow; pulling data into R"
+    warning = paste(
+      "Aggregate within aggregate expression sum\\(\\(dbl - mean\\(dbl\\)\\)\\^2\\)",
+      "not supported in Arrow; pulling data into R"
+    )
   )
 
   compare_dplyr_binding(
@@ -769,7 +792,24 @@ test_that("Not (yet) supported: implicit join", {
       ) %>%
       collect(),
     tbl,
-    warning = "Expression dbl - mean\\(dbl\\) not supported in Arrow; pulling data into R"
+    warning = paste(
+      "Expression dbl - mean\\(dbl\\) is not an aggregate expression",
+      "or is not supported in Arrow; pulling data into R"
+    )
+  )
+
+  compare_dplyr_binding(
+    .input %>%
+      group_by(some_grouping) %>%
+      summarize(
+        dbl
+      ) %>%
+      collect(),
+    tbl,
+    warning = paste(
+      "Expression dbl is not an aggregate expression",
+      "or is not supported in Arrow; pulling data into R"
+    )
   )
 
   # This one could possibly be supported--in mutate()
@@ -781,7 +821,10 @@ test_that("Not (yet) supported: implicit join", {
       ) %>%
       collect(),
     tbl,
-    warning = "Expression dbl - int not supported in Arrow; pulling data into R"
+    warning = paste(
+      "Expression dbl - int is not an aggregate expression",
+      "or is not supported in Arrow; pulling data into R"
+    )
   )
 })
 
@@ -896,3 +939,47 @@ test_that("summarise() passes through type information for temporary columns", {
     )
   )
 })
+
+test_that("summarise() can handle scalars and literal values", {
+  some_scalar_value <- 2L
+
+  compare_dplyr_binding(
+    .input %>% summarise(y = 1L) %>% collect(),
+    tbl
+  )
+
+  compare_dplyr_binding(
+    .input %>% summarise(y = some_scalar_value) %>% collect(),
+    tbl
+  )
+
+  compare_dplyr_binding(
+    .input %>% summarise(y = !! some_scalar_value) %>% collect(),
+    tbl
+  )
+
+  expect_identical(
+    record_batch(tbl) %>% summarise(y = 1L) %>% collect(),
+    tibble(y = 1L)
+  )
+
+  expect_identical(
+    record_batch(tbl) %>% summarise(y = Expression$scalar(1L)) %>% collect(),
+    tibble(y = 1L)
+  )
+
+  expect_identical(
+    record_batch(tbl) %>% summarise(y = Scalar$create(1L)) %>% collect(),
+    tibble(y = 1L)
+  )
+
+  expect_identical(
+    record_batch(tbl) %>% summarise(y = some_scalar_value) %>% collect(),
+    tibble(y = 2L)
+  )
+
+  expect_identical(
+    record_batch(tbl) %>% summarise(y = !! some_scalar_value) %>% collect(),
+    tibble(y = 2L)
+  )
+})
diff --git a/r/tests/testthat/test-duckdb.R b/r/tests/testthat/test-duckdb.R
index 1b3012bcef8..b31fffda95a 100644
--- a/r/tests/testthat/test-duckdb.R
+++ b/r/tests/testthat/test-duckdb.R
@@ -66,6 +66,7 @@ test_that("to_duckdb", {
 })
 
 test_that("to_duckdb then to_arrow", {
+  skip("Flaky, unskip when ARROW-14745 is merged")
   ds <- InMemoryDataset$create(example_data)
 
   ds_rt <- ds %>%
diff --git a/r/tests/testthat/test-type.R b/r/tests/testthat/test-type.R
index 3821fb4503a..8046ebbaa57 100644
--- a/r/tests/testthat/test-type.R
+++ b/r/tests/testthat/test-type.R
@@ -157,9 +157,13 @@ test_that("Type strings are correctly canonicalized", {
     sub("^([^([<]+).*$", "\\1", timestamp()$ToString())
   )
   expect_equal(
-    canonical_type_str("decimal"),
+    canonical_type_str("decimal128"),
     sub("^([^([<]+).*$", "\\1", decimal(3, 2)$ToString())
   )
+  expect_equal(
+    canonical_type_str("decimal128"),
+    sub("^([^([<]+).*$", "\\1", decimal128(3, 2)$ToString())
+  )
   expect_equal(
     canonical_type_str("struct"),
     sub("^([^([<]+).*$", "\\1", struct(foo = int32())$ToString())
diff --git a/r/vignettes/developers/workflow.Rmd b/r/vignettes/developers/workflow.Rmd
index e316dd8fe56..2a1ee23ee94 100644
--- a/r/vignettes/developers/workflow.Rmd
+++ b/r/vignettes/developers/workflow.Rmd
@@ -87,16 +87,18 @@ Fix any style issues before committing with
 ./lint.sh --fix
 ```
 
-The lint script requires Python 3 and `clang-format-8`. If the command
+The lint script requires Python 3 and `clang-format`. If the command
 isn't found, you can explicitly provide the path to it like:
 
 ```bash
-CLANG_FORMAT=$(which clang-format-8) ./lint.sh
+CLANG_FORMAT=/opt/llvm/bin/clang-format ./lint.sh
 ```
 
-On macOS, you can get this by installing LLVM via Homebrew and running the script as:
+You can see what version of `clang-format` is required by the following
+command:
+
 ```bash
-CLANG_FORMAT=$(brew --prefix llvm@8)/bin/clang-format ./lint.sh
+(. ../.env && echo ${CLANG_TOOLS})
 ```
 
 _Note_ that the lint script requires Python 3 and the Python dependencies